#!/usr/bin/perl
use warnings;
use Expect;

# connection parameters
$SERVER = 'host';
$USER = 'user';
$PASS = 'pass';

# spawn the date command on $SERVER running as $USER
my $spawn = Expect->spawn(qq{ssh $USER\@$SERVER date})
or die "Unable to spawn ssh.\n";

$spawn->debug(2);
$spawn->log_stdout(0);

# provide the password when prompted, waiting up to 5 seconds
if ($spawn->expect(5, 'password:')) {
	$spawn->send($PASS . "\n");
}

# wait for the date and print it out
if ($spawn->expect(5, -re => qr/^.*\d{4}.*\n/)) {
	print "The date on $SERVER is " . $spawn->match();
}

• Useful modules for writing CGI in Perl:

  use CGI;
  use URI::Escape;
  

• The common document type of the CGI header

  Content-type: text/html

• Content-type of POST

  The common value of “Content-type” received from a POST HTML form is “application/x-www-form-urlencoded”, although another option for form input (used when submitting files) is “multipart/form-data”.

• HTTP Authentification

  Authorization: Basic dXNlcjpwYXNzd29yZA==

  The encoded portion is simply the username and password joined with a colon and Base64-encoded.

• Cookies

  Set-Cookie: cart_id=12345; path=/;expires=Sat,
  18-Mar-05 19:06:19 GMT
  

package      Bestiary;
require      Exporter;

our @ISA       = qw(Exporter);
our $VERSION   = 1.00;         # Version number

sub new {
    my $invocant = shift;
    my $class = ref($invocant) || $invocant;
    my $self = { @_ };          # Remaining args become attributes
    bless($self, $class);       # Bestow objecthood
    return $self;
}

1;

• alarm n:

  sends a SIGALRM signal to the executing Perl program after n seconds

• caller [n]:

  it returns the package name in a scalar context; in a list context, it returns the package name, filename, and line number from which the currently executing subroutine was called.

• pos $scalar:

  Returns the location in scalar where the last m//g search over scalarleft off.

  $grafitto =~ m/word/g;
  print pos($grafitto));
  

• stat file:

  ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size, $atime,$mtime,$ctime,$blksize,$blocks)
  = stat $filename;

• truncate file, length:

  Truncates a file (given as a filehandle or by name) to the specified length.

Interestingly, assigning to $#array actually changes the size of the array in memory. This allows us both to extend an array without assigning to a higher element and also to truncate an array that is larger
than it needs to be, allowing Perl to return memory to the operating system:

$#array = 999; # extend @array to 1000 elements
$#array = 3; # remove @elements 4+ from array

Truncating an array destroys all elements above the new index, so the last example above is a more efficient way to do the following:

@array = @array[0..3];

This assignment also truncates the array, but by reading out values and then reassigning them. Altering the value of $#array avoids the copy.

A distribution contains the module (or collection of related modules), plus all the support files required to document, test, ship, and install the module. While you could potentially construct all these files by hand, it’s much simpler to use a tool that comes with Perl, awkwardly called h2xs.

$ h2xs -XAn Island::Plotting::Maps
Defaulting to backwards compatibility with perl 5.8.0
If you intend this module to be compatible with earlier perl versions, please
specify a minimum perl version with the -b option.

Writing Island/Plotting/Maps/Maps.pm
Writing Island/Plotting/Maps/Makefile.PL
Writing Island/Plotting/Maps/README
Writing Island/Plotting/Maps/t/1.t
Writing Island/Plotting/Maps/Changes
Writing Island/Plotting/Maps/MANIFEST

Specialised Import Lists

If any of the entries in an import list begins with !, : or / then the list is treated as a series of specifications which either add to or delete from the list of names to import. They are processed left to right. Specifications are in the form:

    [!]name         This name only
    [!]:DEFAULT     All names in @EXPORT
    [!]:tag         All names in $EXPORT_TAGS{tag} anonymous list
    [!]/pattern/    All names in @EXPORT and @EXPORT_OK which match

A leading ! indicates that matching names should be deleted from the list of names to import. If the first specification is a deletion it is treated as though preceded by EFAULT. If you just want to import extra names in addition to the default set you will still need to include EFAULT explicitly.

e.g., Module.pm defines:

    @EXPORT      = qw(A1 A2 A3 A4 A5);
    @EXPORT_OK   = qw(B1 B2 B3 B4 B5);
    %EXPORT_TAGS = (T1 => [qw(A1 A2 B1 B2)], T2 => [qw(A1 A2 B3 B4)]);

Remember that most patterns (using //) will need to be anchored with a leading ^, e.g., “/^EXIT/” rather than “/EXIT/”.

(From manpage Exporter)

As you define classes, you create inheritance hierarchies through the global @ISA variables in each package. To search for a method, Perl wanders through the @ISA tree until it finds a match or fails.

After the search fails however, Perl always looks in one special class called UNIVERSAL and invokes a method from there, if found, just as if it had been located in any other class or superclass.

The methods like: $object->can(…), $object->isa(…) are defined in UNIVERSAL.

package Cow;
use base qw(Animal);

use base has the advantage that it’s performed at compile time, eliminating a few potential errors from setting @ISA at runtime, like some of the other solutions.

sub speak {
    my $class = shift;
    $class->SUPER::speak;
}

SUPER::speak means to look in the current package’s @ISA for speak, invoking the first one found if there’s more than one.

(From “Learning Perl Objects, References and Modules”, O’Reilly)

sort { $a  $b } 1, 10, 9, 8, 20

By default, as Perl orders the items, a string comparison is used. A new comparison is specified using a sort block, placed between the sort keyword and the list of things to sort.

Within the sort block, $a and $b stand in for two of the items to be sorted. The last evaluated expression must return a -1, 0, or +1 value. If the value is -1, the value currently in $a must appear before the value in $b in the final sorted list. If the value is +1, then the value in $a must appear after the value in $b in the final sorted list. If the value is 0, you don’t know or can’t tell, so the results are unpredictable.

For example, to sort those numbers in their proper order, you can use a sort block comparing $a and $b, like so:

my @num_sorted = sort {
  if ($a  $b) { +1 }
  else            {  0 }
} 1, 10, 9, 8, 20;

also, you can use the spaceship operator instead:

my @numerically_sorted = sort { $a  $b }  1, 10, 9, 8, 20;

The spaceship operator returns -1, 0, and +1, according to the rules discussed. A descending sort is as simple as reversing the position of $a and $b:

my @numerically_descending = sort { $b  $a }  1, 10, 9, 8, 20;