This is something I always wanted in Perl and immediately marked a note in my list of blog/CPAN ideas with “Devel::Declare and with statement” (with side note that “using” might be more appropriate so not to clash with Moose roles sugar).

Unsurprisingly this just languished in my ever increasing list

However last month I had a few hours spare one weekend so pulled out my laptop and rummaged through my list and decided to see how difficult it would be to implement “with”.

Unfortunately I kept hitting brick walls with local scoping. I came to conclusion that I may have to use eval or even go down a different track using an AUTOLOAD solution.

I left that weekend experiment with at least a very basic AUTOLOAD proof of concept:

use 5.012;
use warnings;

{
    package FileStuff;
    use Moose;
    
    has name => ( is => 'rw', isa => 'Str' );
    
    sub save { say "save ",   $_[0]->name }
    
    sub del  { say "delete ", $_[0]->name }
    
    sub mv {
        my ($self, $to) = @_;
        say "rename ", $self->name, " to $to";
        $self->name( $to );
    }
    
    sub say { say "Method say: ", @_ }
}

my $f = FileStuff->new( name => 'foobar' );

# using $f {}
{
    local *AUTOLOAD = sub {
        our $AUTOLOAD;
        my $name = (split '::', $AUTOLOAD)[-1];
        die "method $name NOT FOUND!" unless $f->can( $name );
        $f->$name( @_ );
    };
    
    # my "DSL" stuff!
    save();               # $f->save();
    mv( "barbaz" );       # $f->mv( "barbaz" );
    del();                # parenthesis are always required
    say( "builtin say" ); # builtin wins over $f->say
}

I wasn’t sure if this would ever evolve into a robust solution. However I found it reassuring to note that other people had similar problems trying to use local scoping in similar way when I came across this Perlmonks post A useful use of goto a few days later. So this gave the AUTOLOAD approach some merit.

Well chances are this blog post or any additional development may never made it any further. What changed that was an email from chocolateboy this morning pointing me at his new Scope::With CPAN module.

Blimey… Father Christmas had delivered my xmas pressie early and without even seeing my xmas list

chocolateboy’s first example of Scope::With even shows how it works with my Builder module:

use Builder;
use Scope::With;

my $builder = Builder->new();
my $xml = $builder->block('Builder::XML');

with ($xml) {
    body(
        div(
            span({ id => 1 }, 'one'),
            span({ id => 2 }, 'two'),
        )
    );
}

say $builder->render();

Which is exactly why I wanted a “with” statement in Perl and it looked like chocolateboy also felt the same!

The documentation even gave an “using” example:

use Scope::With qw(using);

using ($xml) {
    div(
        span( ... ),
        span( ... ),
    );
}

Getting worried now someone was reading my mind

This is truly awesome stuff. chocolateboy has the habit of producing game changing CPAN modules. For eg. autobox and Method::Lexical. To me Scope::With is potentially another one that falls into this lofty category.

I’m deeply honoured to find my Builder module being referenced and also glad to see that a “with” statement using Devel::Declare and AUTOLOAD isn’t such a delusional idea

So many thanks to chocolateboy for writing Scope::With. Keep up the good work.

/I3az/

PS. chocolateboy’s Scope::With docs also references a prior art module with by Vincent Pit. This module achieves similar things but in different way/implementation.

PPS. CPAN is so big and wonderful that its easy to miss or even forget whats on there!

• Acme::URL
• PerlX::QuoteOperator

The first one you is just a small xmas cracker that you will already know about from my “bare URL” post from last week. Just pull, enjoy for a little while and then chuck away like most xmas cracker toys

The second one is a tad similar (ie. Devel::Declare) but with a much more sympathetic syntax by allowing you to create new Quote-Like Operators in Perl with Perl.

For a good end product exemplar have a look at PerlX::QuoteOperator::URL included with the distribution:

use PerlX::QuoteOperator::URL 'qh';

my $content = qh{ http://transfixedbutnotdead.com/ };

There is no scary parsing going on with this example. PerlX::QuoteOperator / Devel::Declare simply hits the ‘qh’ keyword and converts it to:

qh qq{ http://transfixedbutnotdead.com/ }

And ‘qh’ is a subroutine with a ($) prototype. So nothing too sinister (unless you really do abhor subroutine prototypes!), just a simple macro which gives the appearance that we have new quote-like operators.

Certainly an interesting concept to be able to produce new quote-like operators in Perl. So hopefully PerlX::QuoteOperator might find its way under a few xmas trees

Merry Xmas & happy St. Stephen’s day to everyone.

/I3az/

PS. I chose the PerlX::* because gugod as already provided some wonderful Devel::Declare Perl extending modules under this namespace. I feel its in the same vein so hopefully a good place for it to live.

This will be the first time I’ve “properly” contributed in some form to an opensource project (“properly” being via source control management & a patch).

Devel::Declare is hosted on Github here. And the process to contribute back changes to a Github project is “forking” simple!

With Git & Github its all about forking. Here is a concise Github howto (which I’ll regurgitate below with my own slant & spiel!).

I only use Git for my Github projects, so forking etc is all new to me. To break it down into a few simple steps the process to contribute would be:

• Fork project
• Clone your fork
• Make your changes
• Push changes back to you fork
• Send pull request back to original project

Here are the minutiae steps I went through for Devel::Declare:

• Went to Devel::Declare project on Github and forked it.
• Forked project now appears in my project list.
• Cloned my forked Devel::Declare (use “Your Clone URL” copy/paste)
  git clone git@github.com:draegtun/devel-declare.git
cd devel-declare/


• Linked my forked project to original
  git remote add upstream git://github.com/rafl/devel-declare.git
git fetch upstream


• Make my changes to project
• Run tests (in case I did something stupid!)
  perl Makefile.PL
make
make test


• Clear down build once happy
  make realclean

• Push my changes back to my fork
  git commit -a -m "Documentation added to D::D::Context::Simple + examples directory"
git push origin master


Now on Github the changes can be seen in my fork

All I do now is click the “pull request” button and off went a request of my changes to rafl. Fingers cross my documentation changes were good enough to be accepted.

So I’m no longer a virgin to contributing to this opensource malarky

/I3az/

Some examples from blog post:

# display this JSON request
puts http://github.com/defunkt.json

# => "He nose the truth."
require 'json'
url = http://twitter.com/statuses/show/6592721580.json
JSON.parse(url.to_s)['text']   

Very clever indeed. Of course there will be some edge cases but it does show you how far you can stretch Ruby. NB. Didn’t work in 1.9 for me but worked with minor warning in 1.8.2 (yes I know it old but thats what shipped with Mac OSX Tiger).

So how far can we stretch Perl? Well with Devel::Declare it can be stretched all the way:

use Modern::Perl;
use JSON qw(decode_json);
use URLDSL;

# print the json
say http://twitter.com/statuses/show/6592721580.json;

# => "He nose the truth."
say decode_json( http://twitter.com/statuses/show/6592721580.json )->{text};

So Perl also has no strings attached

Devel::Declare allow us to extend the Perl syntax in a robust and easy fashion:

package URLDSL;
use Modern::Perl;
use Devel::Declare ();
use LWP::Simple ();
use base 'Devel::Declare::Context::Simple';

sub import {
    my $class  = shift;
    my $caller = caller;
    my $ctx    = __PACKAGE__->new;
    
    Devel::Declare->setup_for(
        $caller,
        { 
            http => { 
                const => sub { $ctx->parser(@_) },
            },
        },
    );
    
    no strict 'refs';
    *{$caller.'::http'} = sub ($) { LWP::Simple::get( $_[0] ) };
}

sub parser {
    my $self = shift;
    $self->init(@_);
    $self->skip_declarator;          # skip past "http"

    my $line = $self->get_linestr;   # get me current line of code
    my $pos  = $self->offset;        # position just after "http"
    my $url  = substr $line, $pos;   # url & everything after "http"
    
    for my $c (split //, $url) {
        # if blank, semicolon or closing parenthesis then no longer a URL
        last if $c eq q{ };
        last if $c eq q{;};
        last if $c eq q{)};
        $pos++;
    }    
    
    # wrap the url with http() sub and quotes
    substr( $line, $pos,          0 ) = q{")};
    substr( $line, $self->offset, 0 ) = q{("http};
    
    # pass back changes to parser
    $self->set_linestr( $line );

    return;
}

1;

Here is a low level synopsis of how it worked:

• Devel::Declare tells the perl parser to call parser() when it hits http keyword
• http://twitter.com/statuses/show/6592721580.json example triggers this (perl has no problem naturally distinguishing “http” keyword from “http://”)
• Get line of code in question (my $line = $self->get_linestr; )
• parser() skips along the URL data following “http” ($self->offset) until it reaches a space, semicolon or a closing bracket (this covers “most” cases though comma could be an issue). This marks the end of the URL data
• We now in essence change http://twitter.com/statuses/show/6592721580.json into http("http://twitter.com/statuses/show/6592721580.json")
• And plonk the changed line back to the parser ($self->set_linestr($line);) and let it continue along its merry way
• NB. http() sub was already imported into calling space and returns a LWP::Simple::get of the requested URL

Now is URLDSL useful in the real world? It can screw up syntax highlighting a bit (though WordPress highlighter coped extremely well, unlike Github

Its robust enough to cope with normal string interpolation:

my $id = '6592721580';
say decode_json( http://twitter.com/statuses/show/$id.json )->{text};

So perhaps I should upload it to CPAN? (earmarked for ACME:: perhaps!?). Anyone think this is useful little helper module then I wrap it up the next time I get a free moment.

The exercise as been fruitful in allowing me to get my head into the amazing Devel::Declare module for the first time.

I’ve used the Devel::Declare::Context::Simple class which simplifies things. Unfortunately there isn’t a POD on this yet but the main Devel::Declare docs nicely demonstrate the correct mechanics so its easy to adapt from this.

I also found this blog post by franck cuny to be extremely helpful. As was delving through the source code of other modules that used Devel::Declare

/I3az/