Ever since we added AnyEvent support to Mojolicious through EV, it has been a very popular feature. But so far it required Mojolicious to be in control of the event loop, which limited its usefulness quite a bit. That has changed now, both our web server and user agent have become pretty much indistiguishable from normal AnyEvent components. Today i'm going to demonstrate how you can non-blockingly search Twitter for Perl with the user agent, from a PSGI application running inside the AnyEvent based Twiggy web server. In fact, it should work with any non-blocking capable web framework, such as Catalyst.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

use 5.14.0;
use Mojo::UserAgent;
use Mojo::ByteStream 'b';
use EV;

# Normal PSGI application
my $ua  = Mojo::UserAgent->new;
my $app = sub {
  return sub {
    my $respond = shift;

    # Search Twitter for "perl"
    $ua->get('http://search.twitter.com/search.json?q=perl' => sub {
      my ($ua, $tx) = @_;

      # Respond with first result
      $respond->(
        [ 200,
          ['Content-Type' => 'text/plain'],
          [b($tx->res->json->{results}->[0]->{text})->encode]
        ]
      );
    });
  };
};

Have fun!

Permalink | Leave a comment  »

If you've ever been wondering how a well designed DBIx::Class model for Mojolicious and Mojolicious::Lite applications would look like, Glen Hinkle got you covered with his latest release.

The example application demonstrates DBIx::Class integration, how to test your web app with Test::Mojo, as well as how to use EP templates with and without tag helpers. For those unfamiliar with testing in general, there are even examples of DBIC schema tests.

Have fun!

Permalink | Leave a comment  »

In case you've missed it, there is currently a logo contest for MetaCPAN in progress. I'm generally not a big fan of contests, but since it's for the Perl community, i'm participating as well. Here's what i came up with. (the official entry should later show up here)

No fonts were harmed in the making of this logo, every character is custom made. I tried to combine a retro and futuristic feel, to highlight the long history of Perl and the fact that the CPAN is still science fiction for many programming languages. The three flying pixels are a metaphor for modules, small building blocks that can be combined to form something new. Hope you like it.

Have fun!

Permalink | Leave a comment  »

Happy new year everyone, it's amazing how much Mojolicious has progressed and grown in 2011, Marcus Ramberg has prepared a little retrospection for us.

A new year is upon us, and I figured this would be good time to take a look at the improvements in the Mojolicious framework in the last year. There has been a dazzling number of releases, 122 in fact, including the current release, 2.42.

Have fun!

Permalink | Leave a comment  »

Merry christmas everyone, today Glen "tempire" Hinkle has a special treat for us. In this Mojocast he demonstrates why interacting with the web from Perl has never been this much fun before, you should take a look!

Mojocast Monday brings you a high-level overview of Mojo::UserAgent, the client side of Mojolicious. DOM Walking, CSS selectors, and watching live requests are just a couple of the things you'll see.

Have fun!

Permalink | Leave a comment  »

Happy Mojocast monday everyone. This time Glen "tempire" Hinkle will explain to you the very important task of sharing data between the various parts of a Mojolicious application. So, what are you waiting for? Get over there and learn web development with Perl in no time!

Have fun!

Permalink | Leave a comment  »

By now you've probably heard about WebSockets, and that they are the future of web development, but so far there are very little examples that really show how easy to use they actually are. So today we are going to explore the wonderful world of events in Mojolicious a bit and build a little application that forwards all framework log messages to a browser window. (works best in Chrome)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#!/usr/bin/env perl
use Mojolicious::Lite;

# Documentation under "/perldoc"
plugin 'PODRenderer';

# Template with browser-side code
get '/' => 'index';

# WebSocket log service
websocket '/log' => sub {
  my $self = shift;

  # Subscribe to "message" event of Mojo::Log
  my $cb = $self->app->log->on(message => sub {
    my ($log, $level, @message) = @_;

    # Send message via WebSocket
    $self->send_message("[$level] @message");
  });

  # Unsubscribe again from "message" event of Mojo::Log
  $self->on(finish => sub {
    my $self = shift;
    $self->app->log->unsubscribe(message => $cb);
  });
};

app->start;
__DATA__

@@ index.html.ep
<!doctype html><html>
  <head><title>Mojolicious Log</title></head>
  <body>
    <%= link_to 'New window' => '/perldoc', target => '_blank' %>
    <br/>
    <script>

      // This needs a "Moz" prefix to work in Firefox
      var ws = new WebSocket('<%= url_for('log')->to_abs %>');

      // Incoming WebSocket messages
      ws.onmessage = function(event) {
        document.body.innerHTML += event.data + '<br/>';
      };
    </script>
  </body>
</html>

Have fun!

Permalink | Leave a comment  »

It is now almost a year since our first stable release, and what a great year it has been. The community really exploded, with now over 100 regulars on the IRC channel and 450 watchers on GitHub, making us by far the most successful CPAN module there. Thanks everyone!

Of course we also have many new features for you, here are the highlights:

• Perl 5.10.1: We have finally increased the Perl version requirement and are already using all new features extensively. The performance increase is substantial, especially if you're coming from Perl 5.8.
• Morbo: A brand new self-restarting development web server that just works, even on Windows.
• libev: Native support for the EV event loop and in turn AnyEvent. (example)
• Events: Many objects now emit events, which can be used to extend Mojolicious. (you'll hear much more about this soon, it's very cool)
• Mount plugin: Whole Mojolicious applications can now be embedded easily.
• Groups: Mojolicious::Lite applications became a lot more powerful. (example)
• Hypnotoad: Our primary production web server got a lot more user friendly.
• Collections: Making web scraping a hell of a lot of fun. (example)
• WebSocket testing: You won't believe how easy it can be. (example)

And as usual there is a lot more to discover, see Changes on GitHub for the full list of improvements.

Have fun!

Permalink | Leave a comment  »

Today we are going to use the Mojolicious user agent to scrape Perl headlines from Reddit, and then transform them further with collections, another one of our latest experimental features.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#!/usr/bin/env perl
use Mojo::Base -strict;
use Mojo::UserAgent;

# Lets start by fetching the current top Perl stories from Reddit
my $reddit =
  Mojo::UserAgent->new->get('www.reddit.com/r/perl')->res->dom;

# And extract all titles from the HTML
my $titles =
  $reddit->find('p.title > a.title')->map(sub { $_->text });

# How many do we got?
say 'Found ', $titles->size, ' stories.';

# Wonder how many actually contain the word "Perl"
say $titles->grep(sub {/perl/i})->size, ' contain the word Perl.';

# Top story
say 'Current top story is: ', $titles->first;

# Third story
say 'Third story is: ', $titles->[2];

# Random story that contains the word "Perl"
say 'Random Perl story: ', $titles->shuffle->first(sub {/perl/i});

# And now we go a little crazy :)
say "Stories 2-5 in Base64:\n",
  $titles->slice(1 .. 4)->join('')->b64_encode;

Have fun!

Permalink | Leave a comment  »

Today i'm going to show you one of our latest experimental features. In the past we've mostly encouraged just to use Mojolicious instead of Mojolicious::Lite for all non-trivial applications, but over time it has become clear that even for single file prototypes you sometimes need a little more power. We've addressed this recently with the addition of group blocks, which allow under statements to be nested.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#!/usr/bin/env perl
use Mojolicious::Lite;

# Global logic shared by all routes
under sub {
  my $self = shift;
  return 1 if $self->req->headers->header('X-Bender');
  $self->render(text => "You're not Bender!");
  return;
};

# Admin section
group {

  # Local logic shared only by routes in this group
  under '/admin' => sub {
    my $self = shift;
    return 1 if $self->req->headers->header('X-Awesome');
    $self->render(text => "You're not awesome enough!");
    return;
  };

  # GET /admin/dashboard
  get '/dashboard' => {text => 'Nothing to see here yet!'};
};

# GET /welcome
get '/welcome' => {text => 'Hi Bender!'};

app->start;

And don't forget to give feedback if you like one of our experimental features, or they might never leave the experimental stage. ;)

Have fun!

Permalink | Leave a comment  »

When we recently added the EV backend to Mojolicious, we not only got better performance and scalability, but also native support for AnyEvent. And to demonstrate how easy to use it actually is, we are going to extend the HTML5 EventSource example from last month with some non-blocking IRC goodness today. :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#!/usr/bin/env perl
use Mojolicious::Lite;
use EV;
use AnyEvent::IRC::Client;

# Join #mojo on irc.perl.org
my $irc = AnyEvent::IRC::Client->new;
$irc->connect('irc.perl.org', 6667, {nick => "mojobot$$"});
$irc->send_srv(JOIN => '#mojo');

get '/' => 'index';

get '/events' => sub {
  my $self = shift;

  # Emit "msg" event for every new IRC message
  $self->res->headers->content_type('text/event-stream');
  my $g = $irc->reg_cb(publicmsg => sub {
    my $message = pop->{params}->[1];
    $self->write("event:msg\ndata: $message\n\n");
  });
  $self->on_finish(sub { undef $g });
};

app->start;
__DATA__

@@ index.html.ep
<!doctype html><html>
  <head><title>The Mojolicious IRC channel</title></head>
  <body>
    <script>
      var events = new EventSource('<%= url_for 'events' %>');

      // Subscribe to "msg" event
      events.addEventListener('msg', function(event) {
        document.body.innerHTML += event.data + '<br/>';
      }, false);
    </script>
  </body>
</html>

Have fun!

Permalink | Leave a comment  »

In Mojolicious we care a great deal about testing, after all most of Mojolicious itself was developed using test driven development. Recently WebSockets have turned out to be a real challenge in this regard, their extremely dynamic nature makes it pretty much impossible to design a simple Perl test API that would cover all possible use cases. Luckily we've been supporting WebSockets for quite some time and know by now that the exact message flow is known in advance for the most common ones, which led to this rather pleasant to use API. ;)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#!/usr/bin/env perl
use Mojo::Base -strict;

use utf8;

use Test::More tests => 4;
use Mojolicious::Lite;
use Test::Mojo;

# Tiny echo web service
websocket '/echo' => sub {
  my $self = shift;
  $self->on_message(sub {
    my ($self, $message) = @_;
    $self->send_message("echo: $message");
  });
};

# Send message and receive echo
my $t = Test::Mojo->new;
$t->websocket_ok('/echo')->send_message_ok('I ♥ Mojolicious')
  ->message_is('echo: I ♥ Mojolicious')->finish_ok;

Have fun!

Permalink | Leave a comment  »

Yes, it's finally Mojocasts Monday again! And this time Glen "tempire" Hinkle makes some rather advanced topics like "under" and plugins look trivial. But what's maybe even more impressive than the actual screencast itself is the new HTML5 video player, not only does it provide us with even better video quality, but also the ability to link directly to individual chapters.

Have fun!

Permalink | Leave a comment  »

Sooner or later most web developers stumble over one not so insignificant weakness of CSS3 Selectors, you can't select parent elements. So while you can select img elements with an a parent, you can't select a elements with an img child.

But this has recently been solved in a very clever way with the latest CSS4 Selectors working draft, where you can just change the subject of a selector by prepending a dollar sign to one of the compound selectors. And you might have guessed it, Mojolicious already brings this neat little feature to Perl. :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

use Mojo::DOM;

# Parse HTML5 snippet
my $dom = Mojo::DOM->new(<<EOF);
<div>
  <a href="http://search.cpan.org">
    <img src="/images/search.png">
  </a>
  <a href="http://mojolicio.us">
    <p>Mojolicious</p>
  </a>
  <a href="http://metacpan.org">
    <p><img src="/images/metacpan.png"></p>
  </a>
</div>
EOF

# Add class attribute to all image links
$dom->find('$a img')->each(sub { shift->{class} = 'logo' });

# Render HTML5 snippet
print "$dom";

Have fun!

Permalink | Leave a comment  »

For those not following me on Twitter, "Mojolicious hack of the day" is a little series of fun Perl oneliners i've been posting every now and then over there to demonstrate new Mojolicious features and web technologies. It has been rather popular, but there are many topics that require more than 140 characters, so i'm going to try something new with the blog and post more articles that are heavy on examples, hope you won't mind the lack of walls of text. :)

Today we are going to start with HTML5 EventSource, which is a dead simple technology for streaming DOM events from the server to a browser. Unlike WebSockets, it uses plain old HTTP for transport and is already supported by most common browsers.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#!/usr/bin/env perl
use Mojolicious::Lite;

get '/' => 'index';

get '/events' => sub {
  my $self = shift;

  # Emit "dice" event every second
  $self->res->headers->content_type('text/event-stream');
  my $id = Mojo::IOLoop->recurring(1 => sub {
    my $pips = int(rand 6) + 1;
    $self->write("event:dice\ndata: $pips\n\n");
  });
  $self->on_finish(sub { Mojo::IOLoop->drop($id) });
};

app->start;
__DATA__

@@ index.html.ep
<!doctype html><html>
  <head><title>Roll The Dice</title></head>
  <body>
    <script>
      var events = new EventSource('<%= url_for 'events' %>');

      // Subscribe to "dice" event
      events.addEventListener('dice', function(event) {
        document.body.innerHTML += event.data + '<br/>';
      }, false);
    </script>
  </body>
</html>

Have fun!

Permalink | Leave a comment  »

Glen "tempire" Hinkle has done it again, and this Mojocast looks even better than the last one!

This time you will learn a bit about placeholders, methods and formats in Mojolicious, as well as have some fun with Perl and CSS3 selectors on the command line, hooray!

Permalink | Leave a comment  »

I'm happy to tell you that Glen "tempire" Hinkle has just released the first Mojocast! In this episode you will learn how to install Mojolicious and build your very first web application with it.

Future installments of the series and inclusion of more Perl topics will depend entirely on your feedback, so make sure to leave a comment over on the Mojocasts website.

P.S.: I also hear he's not uninterested in a sponsor.

Permalink | Leave a comment  »

Perl 6 is a great research project and it has been inspiration for many new Perl 5 features over the past 10 years. But its name has also been the cause for a lot of frustration, since it implies that it will be the successor to Perl 5, while in reality there are currently two communities developing two languages.

In response to this there has recently been a lot of discussion about renaming one of the two, but i think there is a much simpler solution to solve this quickly and with little consequences for developers. Why not follow the Linux kernel and drop one part of our three part version numbers?

The next stable release could have the very marketing friendly name Perl 16.0, and should the Perl 6 language ever mature into a worthy successor it can pick a higher version number again, or change the numbering scheme.

So lets just drop the 5 and put Perl 5 back in its rightful place.

Permalink | Leave a comment  »

It fills me with great joy to announce the release of Mojolicious 1.4 (Smiling Face With Sunglasses).

It has been a great 5 months since our first stable release, the community keeps growing rapidly and on GitHub we have now passed Rakudo and are approaching 400 watchers, more than any CPAN module before. Thanks everyone for making it happen!

But lets not get carried away and talk a bit about what amazing new features we have for you this time. :)

HTML manipulation

We've had a great HTML5 parser for some time now, in this release we are going to take it to the next level and turn Mojo::DOM into a real swiss army knife for HTML and XML manipulation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

use 5.14.0;
use Mojo::DOM;

# Let's start with something simple
my $dom = Mojo::DOM->new('<div id="a">A</div>');

# All child elements now have accessors you can use instead of CSS3 selectors
say $dom->div->text;

# You also get direct hash access to element attributes
say $dom->div->{id};

# How about prepending another element
$dom->div->prepend('<div id="a">A</div>');
say "$dom";

# And modify the now-second one to fit in better
$dom->div->[1]->replace_content('B');
$dom->div->[1]->{id} = 'b';
say "$dom";

# Maybe add another nested element to the content of the first one
$dom->div->[0]->append_content('<p>C</p>');
say $dom->div->[0]->p->text;
say "$dom";

Working with XML in Perl has never been this much fun before.

Running oneliners against applications

Perl is one of the most expressive languages out there, why not take advantage of that and allow oneliners to be run right against Mojolicious applications.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

% ./myapp.pl eval -v 'join "\n", sort keys %{app->renderer->helpers}'
app
base_tag
check_box
content
content_for
dumper
extends
file_field
flash
form_for
hidden_field
image
include
input_tag
javascript
layout
link_to
memorize
param
password_field
radio_button
select_field
session
stash
stylesheet
submit_button
tag
text_area
text_field
title
url_for

The possibilities are infinite. :)

Easier long polling

So far we've mostly used the chunked transfer encoding for dynamic long poll streams, this has the huge advantage of allowing connections to be kept alive. But to support Server-Sent Events better we are now also providing raw streams that get terminated with a connection close.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

use Mojolicious::Lite;

get '/' => sub {
  my $self = shift;

  # Write two chunks right away
  $self->write("first\n");
  $self->write("second\n");

  # Wait 3 seconds and write last chunk
  Mojo::IOLoop->timer(3 => sub {
    $self->finish("third\n");
  });
};

app->start;

Embedding applications in scripts

From time to time you might want to reuse parts of Mojolicious applications like configuration files, database connection or helpers for other scripts, now you can just use this little mock server to embed them.

1
2
3
4
5
6
7
8
9

use 5.14.0;
use Mojo::Server;

# Load application with mock server
my $server = Mojo::Server->new;
my $app = $server->load_app('./myapp.pl');

# Access fully initialized application
say $app->static->root;

And as usual there is a lot more to discover, see Changes on GitHub for the full list of improvements.

Have fun!

Permalink | Leave a comment  »

Today is a great day for Perl web development, with DotCloud finally adding Perl support we now have two cloud hosting providers to choose from. Even though Phenona started their beta about two weeks ago, it seems very limited and there is not much known about it yet, maybe i'll get to write about them next time.

My first impressions of DotCloud have been quite pleasant so far, it basically allows you to completely ignore infrastructure questions and to concentrate on what's really important, your application. All you have to do to get started is claim your API key on the website and install the Python command line client via "easy_install".

1
2

% sudo easy_install dotcloud
...

Every DotCloud Perl application requires two essential files, a "Makefile.PL" containing a list of CPAN dependencies and a "app.psgi" file used to start the application with a PSGI compliant web server. (Nginx + uWSGI)

1
2
3
4
5

% mkdir hellomojo
% cd hellomojo
% touch myapp.pl
% touch Makefile.PL
% touch app.psgi

For our little Hello World example we will use a separate "myapp.pl" file, this is not necessary but will simplify the use of Mojolicious debugging tools later on.

1
2
3
4
5
6
7
8

#!/usr/bin/env perl
use Mojolicious::Lite;

get '/' => sub {
  shift->render_text('Hello Mojo!');
};

app->start;

The separate PSGI file also makes switching modes very easy.

1
2

$ENV{MOJO_MODE} = 'production';
require 'myapp.pl';

Our only dependency for this experiment will be Mojolicious, but DotCloud can automatically install any CPAN module you specify.

1
2
3
4
5
6

#!/usr/bin/env perl
use ExtUtils::MakeMaker;

WriteMakefile(
  PREREQ_PM => {'Mojolicious' => '1.21'}
);

It only takes a few simple commands to deploy our application and make it publicly available at http://www.hellomojo.dotcloud.com.

1
2
3
4
5
6
7
8

% dotcloud create hellomojo
...
% dotcloud deploy --type perl hellomojo.www
...
% dotcloud push hellomojo.www .
...
% dotcloud run hellomojo.www
...

I have not yet tried the huge selection of databases available, but am very much looking forward to it.

Have fun! :)

Permalink | Leave a comment  »