CPAN::Groonga

@dirs = split("/", $directories);
    @dirs = @dirs.map:{ split("\\", $_) };
    if (($directories ~~ rx:P5"[\\/]\Z(?!\n)")) {
        @dirs[@dirs - 1] = '';
    }
    @dirs = map {~$_ }, @dirs;
    r

($nofile) {
        $path ~~ rx:P5"^((?:[a-zA-Z]:|(?:\\\\|//)[^\\/]+[\\/][^\\/]+)?)(.*)";
        $volume    = ~$0;
        $directory = ~$1;
    }
    else {
        $path ~~ rx:P5"^((?:[a-zA-Z]:|(?:

ew_path;
    my $i = 0;
    loop ($i = 0; $i < @path; $i++) {
        @path[$i] ~~ s:P5:g"/"\\";
        if (@path[$i] ~~ m:P5"\\$") {
            push(@new_path, @path[$i]);
        }
        else {

lan 25;

if !eval('("a" ~~ /a/)') {
  skip_rest "skipped tests - rules support appears to be missing";
} else {

# Testing the parsing of verious forms of numbers

is(?("1"  ~~ /^<Int>$/),Bool::True,"

 ~~ /^<Int>$/),Bool::True,"-1 is parsed as an integer");

is(?("1."  ~~ /^<Rat>$/),Bool::True,"1. is parsed as a Rat");
is(?("-1."  ~~ /^<Rat>$/),Bool::True,"-1. is parsed as a Rat");

is(?("0.1"  ~~ 

"  ~~ /^<Rat>$/),Bool::True,"0.1 is parsed as a Rat");

is(?(".1"  ~~ /^<Rat>$/),Bool::True,".1 is parsed as a Rat");
is(?("-.1"  ~~ /^<Rat>$/),Bool::True,".1 is parsed as a Rat");

is(?("10.01"  ~~ /

> 0,
    }

=item *

C<DEFAULT> - the default configuration. 

Sample Password:

    ~~12:settle:SUCCEED:summer:48~~
    
Preset Definition:

    {
        symbol_alphabet => [qw{! @ $ % ^ & * - _ + =

lue })>

Pass a hashref of options to the constructor for Ossec::Log::Parse. Options that
can be given (in descending order of importance):

=over 4

=item B<fh>

Filehandle to be used as data source.

lue })>

Pass a hashref of options to the constructor for Ossec::Log::Parse. Options that
can be given (in descending order of importance):

=over 4

=item B<fh>

Filehandle to be used as data source.

T)>

=item C<new(NAME)>

Constructor. FILE, NAME or TEXT are optional arguments.

When a name is given (a string without 'C</>', 'C<\>' or 'C<.>') a lookup is
done using File::BaseDir. If the file fou

ne_hash => [ $_->id ]);
            if ($f) {
                next if $f->id ~~ $_->id;
                next if $f->value ~~ $_->value;
            }
            error 1, 'select exists tuple';
      

id ], TNT_FLAG_RETURN);
            if ($f) {
                next if $f->id ~~ $_->id;
                next if $f->value ~~ $_->value;
            }
            error 1, 'delete exists tuple';
      

ne_tree => [ $_->id ]);
            if ($f) {
                next if $f->id ~~ $_->id;
                next if $f->value ~~ $_->value;
            }
            error 1, 'select exists tuple';
      

id ], TNT_FLAG_RETURN);
            if ($f) {
                next if $f->id ~~ $_->id;
                next if $f->value ~~ $_->value;
            }
            error 1, 'delete exists tuple';
      

ct to another.

=head2 hex_neighbor ($direction)

Returns a new neighboring hex in the direction given (0-5).

=head1 AUTHOR

David Farrell <dfarrell@cpan.org>

=head1 COPYRIGHT AND LICENSE

This soft

ult returns the closest 
full stop aperture between 1 and 64.

If the optional third argument is given (a reference to a list of
possible aperture values), then the returned aperture will be
the close

the closest
full stop between 1920s (32 minutes) and 1/8000s.

If the optional third argument is given (a reference to a list
of possible shutter speeds), then the returned shutter speed
will be the c

    Test scripts modifed, external modules eleminated.
#       compareOrder() modified, it's using ~~ smart-match operator.
#       Documentation updated.
# 2012-06-25 v1.0.0   H. Klausing
#       Ini

 avoid Argument "?undef?" isn't numeric in smart match

        if (not($item ~~ @exclude)) {
            if (not $item ~~ @resultList) {
                push(@resultList, ($item ne UNDEF) ? $item : u

   my $item = $arr_ref->[$i] // UNDEF;
                no warnings;

                if (not($item ~~ @outList)) {
                    unshift(@outList, $item);
                }
                use w

 [@_];
     my $elt_type= $tc->[1]->[0];
     if (!isprim($elt_type)) {
         if (not ($tc->[1] ~~ $v->[0]->{Type}->[1]) ) {
              die "Type error in Array type check:";
         }
     }
 

ore, we can do something similar to pattern matching by using a variant() function like this:

  given(variant $t) {
	when (Just) : untype $t;
	when (Nothing) : <do something else>
  }
  
So variant()

'Type' => $a->{Type}->[2]};    
}
sub unshift {
    (my $a, my $v) =@_;
            if ($v->{Type} ~~ $a->{Type}[2]) {           

    unshift @{$a->{Val}}, $v->{Val};
     } else {
            die "T

O "Your system is Windows. I won't even bother calculating your schlong-size, sorry!" unless! ($^O ~~ /Win/ ... /Win/) # Just for fun (again)
    }

    sub true  { 1 }
    sub false { 0 }

    # The 

 0 }
    method _build_using_tmux             { $ENV{TERM} ~~ 'tmux'       ? 1 : 0 }
    method _build_using_screen           { $ENV{TERM} ~~ 'screen'     ? 1 : 0 }
    method _build_perl_version     

           { $self->shell ~~ 'bash' || 0 }
    method _build_using_zsh              { $self->shell ~~ 'zsh'  || 0 }
    method _build_using_ksh              { $self->shell ~~ 'ksh'  || 0 }
    method 

nice_name_for( $attr, $type ) {
    use feature 'switch';
    use experimental 'smartmatch';
    given( ref $attr ) {
        when( 'CODE' ) { return "unnamed RSS ${type}"; }
        when( q{}    ) { 

SS items" if not defined $attr;
    use feature 'switch';
    use experimental 'smartmatch';
    given( ref $attr ) {
        when( 'CODE' ) {
            return $attr;
        }
        when( q{} ) {

l's
C<reftype $reference> to determine which key to look for.

If no suitable key/value pair was given (e.g. C<$reference> is an C<ARRAY>
reference but no C<< ARRAY => sub {...} >> pair exists), C<swi

   while( @list ) {
        use experimental 'smartmatch';
        use feature 'switch';
        given( shift @list ) {
            when( 'HASH'  eq ref $_ ) { push @results, [ %{ $_ } ] }
           

y scaned', $indb->{size}),
            $filelist_line->( { %$f, %$indb } ), next, if $indb->{size} ~~ $f->{size};
            #$db->select('filelist', {path=>$f->{path},file=>$f->{file}, });
         

$curdir) = m{^Directory Name="([^"]+)">}i ) {    #"mcedit
        $dir .= ( ( !length $dir and $^O ~~ [ 'MSWin32', 'cygwin' ] ) ? () : '/' ) . $curdir;
        #$self->log 'now in', $dir;
        #$se

bz2',
    );
    psmisc::unlock('sharescan');
    #$_[0]->( $sharesize, $sharefiles ) if ref $_[0] ~~ 'CODE';
    #( $self->{share_size} , $self->{share_files} ) = ( $sharesize, $sharefiles );
    $sh

ntscale};
}

# Determine the current font and set font-related members.
# If $plain_with_size is given (a number), use a plain font
# of that size.  Otherwise, use the font specified by the
# HTML con

consisting of the result of using the given class to format the
given HTML file according to the given (optional) options. Internally it calls
C<< SomeClass->new( ... )->format( ... ) >> on a new HTML

nsisting of the result of using the given class to format the
given HTML source according to the given (optional) options. Internally it
calls C<< SomeClass->new( ... )->format( ... ) >> on a new HTML

= $ua->request($req);

		if ( $res->is_success ) {
			$rubies->{$version} = [];
			for ( grep { $_ ~~ /ruby.*\.tar\.bz2/ } split '\n', $res->content ) {
				my $at = $self->archive_type;
				( my $rub

nstalled;

		my $installed = $self->installed_rubies->{$major_version};

		if ($self->ruby_version ~~ @$installed){
			$self->gemset($gemset);
			$self->_setup_environment;

			$self->_sub_shell;
		}

nstalled;

		my $installed = $self->installed_rubies->{$major_version};

		if ($self->ruby_version ~~ @$installed){
			my $dir = File::Spec->catdir($self->rootdir, 'gemsets', $self->major_version, $se