The module is used as follows:

my $uri = $q->param('uri')||"";
my $uriobj = URI::Fusker->new(uri => $uri, maximum => 100);
my @urls = $uriobj->as_list;
#After which @urls is popped into a template, printed, etc
[download]

And here is the module code:

package URI::Fusker;
#copyright 2001, 2002 carthagtuek@softhome.net

#####################################################################

use strict;

#####################################################################

require Exporter;

our @ISA         = qw(Exporter);
our @EXPORT      = qw();
our @EXPORT_OK   = qw(length generateList generateSequences generateRa
+nges);
our %EXPORT_TAGS = (
                     All => [qw(length generateList generateSequences 
+generateRanges)]
                   );
our $VERSION     = 1.0;

#####################################################################

sub new
{
    my $class = shift;
    
    my $self = {
                uri => "",
                maximum => 10000, #Default maximum length for the gene
+rated list
                @_
               };
    
    return bless $self, $class;
}

#####################################################################

sub as_list
{
    my $self = shift;
    
    if ($self->length <= $self->{maximum})
    {
        return generateList($self->{uri});
    }
    else
    {
        return; #Todo: Make a shorter list.
    }
}

sub uri
{
    my $self = shift;
    
    if (@_) { $self->{uri} = shift }
    
    return $self->{uri};
}

sub maximum
{
    my $self = shift;
    
    if (@_) { $self->{maximum} = shift }
    
    return $self->{maximum};
}

#####################################################################

sub length
{
    my ($self, $uri);
    my $length = 0;
    
    if (ref($_[0]))
    {
        $self = shift;
        $uri = $self->{uri};
    }
    else
    {
        $uri = shift;
    }
    
    while ($uri =~ m/((?:\{[^\}]+\})|(?:\[[^\]]+\]))/ig)
    {
        if    ($1 =~ m/\{([^\}]+)\}/i)
        {
            $length++;
            $length++ while ($1 =~ m/,/);
        }
        elsif ($1 =~ m/\[([^\]]+)\]/i)
        {
            my ($start, $stop) = sort split('-',$1);
            
            $length += $stop - $start + 1;
        }
    }
        
    return $length;
}

#####################################################################

sub generateList
{
    my @urls = @_;
    
    while (grep /\{[^\}]+\}/, @urls) 
    {    #as long as there are {}s in the url list, split out the sequ
+ences.
        @urls = generateSequences(@urls);
    }
    
    while (grep /\[[^\]]+\]/, @urls) 
    {    #as long as there are []s in the url list, split out the rang
+es.
        @urls = generateRanges(@urls);
    }
    
    return @urls;
}

sub generateSequences
{
    my @strings = ();
    
    while (@_)
    {
        my $string = shift @_;
        $string =~ /^([^\{]+)\{([^\}]+)\}(.*)$/;    #something{somethi
+ng}something
        my $begin = $1||'';
        my $mid = $2||'';
        my $end = $3||'';
        
        if ($mid)
        {    #there were a set of {}
            my @items = split(',',$mid);
            
            foreach (@items)
            {    #Taking each item and putting it in the list.
                push @strings, "$begin$_$end";
            }
        }
        else
        {    #there weren't, let's just push the string back out again
            push @strings, $string;
        }
    }
    
    return @strings
}

sub generateRanges
{
    my @strings = ();
    
    while (@_)
    {
        my $string = shift @_;
        $string =~ /^([^\[]+)\[([^\]]+)\](.*)$/;    #something[somethi
+ng]something
        my $begin = $1||'';
        my $mid = $2||'';
        my $end = $3||'';
        
        if ($mid)
        {    #there were a set of []
            my ($start, $stop, undef) = sort split('-',$mid);
            my $digits = 0;
            
            if ($start =~ /\d+/)
            {    #There is one or more digit, so we'll remove anything
+ else that might be there
                $digits = length($start);
                $start =~ s/\D+//g;
                $stop =~ s/\D+//g;
            }
            
            #Catching crap input here:
            $stop = substr("000000$stop",-length($start)) if ($stop =~
+ /^0/); #Make sure they are the same length, eh
            
            foreach ($start .. $stop)
            {    #Taking each item and putting it in the list.
                push @strings, "$begin".("0"x($digits-length($_)))."$_
+$end";
            }
        }
        else
        {    #there weren't, let's just push the string back out again
            push @strings, $string;
        }
    }
    
    return @strings
}

#####################################################################

1;

__END__

=head1 NAME

URI::Fusker - URL generation based on ranges and sequences

=head1 SYNOPSIS

 $uri = URI::Fusker->new("http://www.server.com/directory/{a,b,c}/[1-1
+0].html");
 @urls = $uri->as_list;

=head1 DESCRIPTION

This module emulates the part of the behaviour of the commandline tool
+ cURL. In particular,
it makes possible URL generation based on ranges and sequences as foll
+ows:

=over 3

=item *

An URL containing a range like [1-10] will be expanded to a number of 
+URLs, each with a
number from the range.

=item *

An URL containing a sequence like {a,b,c} will be expanded into a numb
+er of URLs, each
with an item from the sequence.

=back

Thus, in the example seen in L</SYNOPSIS>, 30 URLs will be generated.

=head2 Methods

=over 3

=item new( [uri => ""], [maximum => 10000] )

Creates a new URI::Fusker object. The uri parameter is the uri from wh
+ich to generate
the list, and the maximum parameter is the maximum length (the default
+ is 10,000) of
said list.

=item $uri->as_list

Creates the list using the associated uri, unless the list will be lon
+ger than the set
maximum.

=item $uri->uri([$uri])

Sets or returns the uri for the object.

=item $uri->maximum([$max])

Sets or returns the maximum length of the object.

=item $uri->length

Will attempt to calculate the length of the list that is to be generat
+ed.

=item generateList($uri)

Will generate the list regardless of the length. Be careful, this can 
+be very memory
intensive. It is suggested to only use L</as_list>.

=head1 AUTHOR

Mikkel Eriksen, carthagtuek@softhome.net

=head1 SEE ALSO

http://curl.haxx.se/

=head1 COPYRIGHT

Copyright 2002 Mikkel Eriksen.

This program is free software. You may copy or redistribute it under t
+he same terms as Perl itself.

=cut
[download]