Управление реальными программами

    ok(   1, 'the number one should be true'         );
    ok(   0, '... and zero should not'               );
    ok(  '', 'the empty string should be false'      );
    ok( '!', '... and a non-empty string should not' );

    done_testing();

    ok 1 - the number one should be true
    not ok 2 - ... and zero should not
    #   Failed test '... and zero should not'
    #   at truth_values.t line 4.
    not ok 3 - the empty string should be false
    #   Failed test 'the empty string should be false'
    #   at truth_values.t line 5.
    ok 4 - ... and a non-empty string should not
    1..4
    # Looks like you failed 2 tests of 4.

    $ prove truth_values.t
    truth_values.t .. 1/?
    #   Failed test '... and zero should not'
    #   at truth_values.t line 4.

    #   Failed test 'the empty string should be false'
    #   at truth_values.t line 5.
    # Looks like you failed 2 tests of 4.
    truth_values.t .. Dubious, test returned 2
        (wstat 512, 0x200)
    Failed 2/4 subtests

    Test Summary Report
    -------------------
    truth_values.t (Wstat: 512 Tests: 4 Failed: 2)
      Failed tests:  2-3

Тут много вывода, отображающего то, что и так очевидно: второй и третий тесты проваливаются, потому что ноль и пустая строка являются ложными значениями. Эти провалы легко исправить, инвертировав смысл условий с помощью булева приведения типов (Булево приведение типов):

    ok(   ! 0, '... and zero should not'          );
    ok(  ! '', 'the empty string should be false' );

После этих двух изменений prove выводит следующее:

    $ prove truth_values.t
    truth_values.t .. ok
    All tests successful.

Смотрите в perldoc prove полезные опции тестов, такие как параллельный запуск тестов (-j), автоматическое добавление lib/ во включаемые пути Perl (-l), рекурсивный запуск всех файлов тестов, найденных в t/ (-r t) и запуск медленных тестов сначала (--state=slow,save).

Псевдоним оболочки bash proveall может оказаться полезным:

    alias proveall='prove -j9 --state=slow,save -lr t'

Лучшее сравнение

Хотя сердце всех автоматизированных тестов — булево условие «истинно или ложно?», сведение всего к этому булеву условию утомительно и даёт небольшие диагностические возможности. Test::More предоставляет несколько других удобных функций проверок.

Функция is() сравнивает два значения, используя оператор eq. Если значения равны, тест проходит. В противном случае, тест проваливается с диагностическим сообщением:

    is(         4, 2 + 2, 'addition should work' );
    is( 'pancake',   100, 'pancakes are numeric' );

Как вы можете предположить, первый тест проходит, а второй — проваливается.

    t/is_tests.t .. 1/2
    #   Failed test 'pancakes are numeric'
    #   at t/is_tests.t line 8.
    #          got: 'pancake'
    #     expected: '100'
    # Looks like you failed 1 test of 2.

Тогда как ok() предоставляет только номер строки провалившегося теста, is() отображает ожидаемое и полученное значение.

is() налагает неявный скалярный контекст на свои значения (Прототипы). Это означает, например, что вы можете проверить количество элементов в массиве без необходимости явного вычисления массива в скалярном контексте:

    my @cousins = qw( Rick Kristen Alex
                      Kaycee Eric Corey );
    is( @cousins, 6, 'I should have only six cousins' );

…хотя некоторые для ясности предпочитают писать scalar @cousins.

Соответствующая функция Test::More isnt() сравнивает два значения, используя оператор ne, и проходит, если они не равны. Она также налагает скалярный контекст на свои операнды.

И is(), и isnt() используют строковое сравнение с помощью операторов Perl 5 eq и ne. Это почти всегда то, что нужно, но для сложных значений, таких как объекты с перегрузкой (Перегрузка) или двойные переменные (Двойные переменные), вы можете предпочесть явное тестирование сравнения. Функция cmp_ok() позволяет вам указать свой собственный оператор сравнения:

    cmp_ok( 100, $cur_balance, '<=',
           'I should have at least $100' );

    cmp_ok( $monkey, $ape, '==',
           'Simian numifications should agree' );

Классы и объекты предоставляют свои собственные интересные способы взаимодействия с тестами. Протестировать, что класс или объект расширяет другой класс (Наследование), можно с помощью isa_ok():

    my $chimpzilla = RobotMonkey->new();
    isa_ok( $chimpzilla, 'Robot' );
    isa_ok( $chimpzilla, 'Monkey' );

isa_ok() предоставляет свои собственные диагностические сообщенния при провалах.

can_ok() проверяет, что класс или объект может выполнить запрошенный метод (или методы):

    can_ok( $chimpzilla, 'eat_banana' );
    can_ok( $chimpzilla, 'transform', 'destroy_tokyo' );

Функция is_deeply() сравнивает две ссылки, чтобы убедиться, что их содержимое идентично:

    use Clone;

    my $numbers   = [ 4, 8, 15, 16, 23, 42 ];
    my $clonenums = Clone::clone( $numbers );

    is_deeply( $numbers, $clonenums,
         'clone() should produce identical items' );

Если сравнение проваливается, Test::More сделает всё, что в его силах, чтобы предоставить разумную диагностику, указывающую позицию первого несоответствия между структурами. Для более настраиваемых тестов смотрите CPAN-модули Test::Differences и Test::Deep.

В Test::More есть ещё несколько тестовых функций, но эти наиболее полезны.

Организация тестов

CPAN-дистрибутивы должны включать директорию t/, содержающую один или более файлов тестов, имеющих расширение .t. По умолчанию, когда вы собираете дистрибутив с помощью Module::Build или ExtUtils::MakeMaker, этап тестирования запускает все файлы t/*.t, суммирует их вывод, и проходит успешно или проваливается в зависимости от результатов набора тестов как целого. Нет конкретных руководств, как управлять содержимым отдельных файлов .t, хотя наиболее популярны две стратегии:

• Каждый файл .t должен соответствовать файлу .pm.
• Каждый файл .t должен соответствовать некоторому функционалу.

Смешанный подход наиболее гибок; один тест может проверять, что все ваши модули компилируются, тогда как другие тесты будут проверять, что каждый модуль ведёт себя так, как ожидается. Когда дистрибутив разрастается, полезность управления тестами в привязке к функционалу становится более привлекательной; большие тестовые файлы сложнее поддерживать.

Кроме того, раздельные файлы тестов могут ускорить разработку. Если вы добавляете способность дышать огнём к вашему классу RobotMonkey, вы, вероятно, захотите запускать только тестовый файл t/breathe_fire.t. Когда же вы добъётесь удовлетворительной работы функционала, запустите весь набор тестов для проверки того, что локальные изменения не имеют непреднамеренных глобальных эффектов.

Другие модули для тестирования

Test::More полагается на тестовый бэкенд, известный как Test::Builder. Этот модуль управляет планом тестов и приводит вывод тестов в TAP. Такой дизайн позволяет множеству тестовых модулей использовать один и тот же бэкенд Test::Builder. Вследствие этого, на CPAN доступны сотни тестовых модулей — и все они могут работать вместе в одной и той же программе.

• Test::Fatal помогает протестировать, что ваш код выбрасывает (и не выбрасывает) исключения соответствующим образом. Вам также может встретиться Test::Exception.
• Test::MockObject и Test::MockModule позволяют вам тестировать сложные интерфейсы, имитируя (mocking) их (эмулируя, но производя другие результаты).
• Test::WWW::Mechanize помогает тестировать веб-приложения, тогда как Plack::Test, Plack::Test::Agent и подкласс Test::WWW::Mechanize::PSGI могут делать это, не используя внешний живой веб-сервер.
• Test::Database предоставляет функции для тестирования правильного и неправильного использования баз данных. DBICx::TestDatabase помогает тестировать схемы, сгенерированные с помощью DBIx::Class.
• Test::Class предлагает альтернативный механизм организации наборов тестов. Он позволяет вам создавать классы, в которых конкретные методы группируют тесты. Вы можете наследовать от этих тестовых классов, так же как ваши классы кода наследуют друг от друга. Это превосходный способ уменьшить дублирование в тестовых наборах. См. превосходную серию статей по Test::Class Кёртиса Пое (Curtis Poe) (footnote: http://www.modernperlbooks.com/mt/2009/03/organizing-test-suites-with-testclass.html). Более новый дистрибутив Test::Routine предлагает аналогичные возможности посредством использования Moose (Moose).
• Test::Differences тестирует строки и структуры данных на идентичность и отображает любые найденные различия в своей диагностике. Test::LongString добавляет похожие проверки.
• Test::Deep тестирует идентичность вложенных структур данных (Вложенные структуры данных).
• Devel::Cover анализирует выполнение ваших наборов тестов и даёт отчёт о количестве кода, которое тесты действительно выполняют. В общем, чем больше покрытие, тем лучше — хотя стопроцентное покрытие не всегда возможно, 95% гораздо лучше, чем 80%.

См. проект Perl QA (http://qa.perl.org/) для большей информации о тестировании в Perl.

Обработка предупреждений

    warn 'Something went wrong!';

warn выводит список значений в файловый дескриптор STDERR (Ввод и вывод). Perl будет добавлять имя файла и номер строки, на которой произошёл вызов warn, если последний элемент списка не заканчивается переводом строки.

Встроенный модуль Carp предлагает другие механизмы для генерации предупреждений. Его функция carp() выводит предупреждение с точки зрения вызывающего кода. Если есть такая валидация параметров функции:

    use Carp 'carp';

    sub only_two_arguments
    {
        my ($lop, $rop) = @_;
        carp( 'Too many arguments provided' ) if @_ > 2;
        ...
    }

…предупреждение об арности (Арность) будет включать имя файла и номер строки вызывающего кода, а не only_two_arguments(). cluck() из того же модуля Carp аналогично генерирует обратную трассировку всех вызовов функций до текущей функции.

Многословный режим Carp добавляет обратную трассировку ко всем предупреждениям, генерируемым carp() и croak() (Оповещение об ошибках) по всей программе:

    $ perl -MCarp=verbose my_prog.pl

Используйте Carp при написании модулей (Модули) вместо warn или die.

Включение и выключение предупреждений

В старом коде вы можете встретить аргумент командной строки -w. Он включает предупреждения по всей программе, даже во внешних модулях, написанных и поддерживаемых другими людьми. Тут всё или ничего, хотя это и может быть полезным, если у вас есть необходимые средства для устранения и предупреждений, и потенциальных предупреждений по всей кодовой базе.

Современный подход — использование прагмы warnings (footnote: …или эквивалента, такого как use Modern::Perl;.). Это включает предупреждения в лексической области видимости и указывает, что автор кода не подразумевает, что в нормальных условиях он будет генерировать предупреждения.

Флаг -W включает предупреждения по всей программе в одностороннем порядке, независимо от лексического включения или выключения с помощью прагмы warnings. Флаг -X отключает предупреждения по всей программе в одностороннем порядке. Ни один из них не имеет широкого распространения.

Все эти флаги, -w, -W и -X, воздействуют на глобальную переменную $^W. Код, написанный до появления прагмы warnings (Perl 5.6.0 весной 2000 года) может локализовать $^W, чтобы подавить некоторые предупреждения в пределах заданной области видимости.

Отключение категорий предупреждений

Чтобы отключить выбранные предупреждения в области видимости, используйте no warnings; со списком аргументов. Опускание списка аргументов отключает все предупреждения в этой области видимости.

perldoc perllexwarn приводит список всех категорий предупреждений, которые ваша версия Perl 5 воспринимает с прагмой warnings. Большая часть из них представляет действительно интересные условия, но некоторые могут быть явно бесполезны в ваших конкретных обстоятельствах. Например, предупреждение recursion будет происходить, если Perl обнаружил, что функция вызвала себя более чем сто раз. Если вы уверены в своей способности написать условия завершения рекурсии, вы можете отключить это предупреждение в области видимости рекурсии (хотя хвостовые вызовы, возможно, подойдут лучше; Хвостовые вызовы).

Если вы генерируете код (Кодогенерация) или локально переопределяете символы, вам может понадобиться отключить предупреждение redefine.

Некоторые опытные Perl-хакеры отключают предупреждение об неинициализированных значениях (uninitialized) в коде обработки строк, который конкатенирует значения из множества источников. Тщательная инициализация переменных помогает избежать необходимости отключения предупреждения, но локальный стиль и лаконичность могут сделать использование этого предупреждения спорным.

Сделать предупреждения фатальными

    use warnings FATAL => 'all';

    use warnings FATAL => 'deprecated';

    {
        my $warning;
        local $SIG{__WARN__} = sub { $warning .= shift };

        # сделать что-нибудь рискованное
        ...

        say "Caught warning:\n$warning" if $warning;
    }

    package Scary::Monkey;

    use warnings::register;

    package Scary::Monkey;

    use warnings::register;

    sub import
    {
        warnings::warnif( 'deprecated',
            'empty imports from ' . __PACKAGE__ .
            ' are now deprecated' )
        unless @_;
    }

    open my $fh, '<', 'filename'
        or die "Cannot read '$filename': $!\n";

    open my $read_fh,  '<', \$fake_input;
    open my $write_fh, '>', \$captured_output;

    do_something_awesome( $read_fh, $write_fh );

    open my $fh, "> $some_file"
        or die "Cannot write to '$some_file': $!\n";

    open my $fh, '<', 'some_file';

    while (<$fh>)
    {
        chomp;
        say "Read a line '$_'";
    }

    open my $fh, '<', 'some_file';

    while (defined($_ = <$fh>))
    {
        chomp;
        say "Read a line '$_'";
        last if eof $fh;
    }

    open my $fh, '<', $filename;

    while (my $line = <$fh>)
    {
        chomp $line;
        ...
    }

Perl по умолчанию работает с файлами в текстовом режиме. Если вы читатете двоичные данные, такие как медиафайл или сжатый файл — используйте binmode прежде чем выполнять какой-либо ввод/вывод. Это укажет Perl обрабатывать данные файла как чистые данные, никаким образом их не модифицируя (footnote: Модификации включают перевод \n в платформозависимую последовательность новой строки.). Хотя на Unix-подобных платформах binmode может быть не всегда обязателен, переносимые программы играют наверняка (Юникод и строки).

Запись в файлы

Имея открытый для вывода дескриптор файла, осуществляйте вывод в него с помощью print или say:

    open my $out_fh, '>', 'output_file.txt';

    print $out_fh "Here's a line of text\n";
    say   $out_fh "... and here's another";

Обратите внимание на отсутствие запятой между дескриптором файла и следующим операндом.

Perl Best Practices Демьена Конвея (Damian Conway) рекомендует придерживаться привычки заключать дескриптор файла в фигурные скобки. Это необходимо для устранения неоднозначности парсинга дескриптора файла, содержащегося в агрегатной переменной, и ничему не повредит в более простых случаях.

И print, и say принимают список операндов. Perl 5 использует магическую глобальную переменную $, как разделитель значений списка. Perl также использует любое значение $\ как последний аргумент print или say. Так что эти две строки кода дают один и тот же результат:

    my @princes = qw( Corwin Eric Random ... );

    print @princes;
    print join( $,, @princes ) . $\;

Закрытие файлов

Когда вы закончили работать с файлом, закройте его дескриптор явно с помощью close, или дайте ему выйти из области видимости. Perl закроет его для вас. Преимущество явного вызова close в том, что вы можете проверить — и восстановиться после них — специфические ошибки, такие как недостаток места на устройстве хранения или разорванное сетевое соединение.

Как обычно, autodie выполнит эти проверки за вас:

    use autodie;

    open my $fh, '>', $file;

    ...

    close $fh;

Специальные переменные обработки файлов

    open my $fh, '>', 'pecan.log';
    $fh->autoflush( 1 );

    ...

    opendir my $dirh, '/home/monkeytamer/tasks/';

    # итерация
    while (my $file = readdir $dirh)
    {
        ...
    }

    # разглаживание в список
    my @files = readdir $otherdirh;

    use 5.012;

    opendir my $dirh, 'tasks/circus/';

    while (readdir $dirh)
    {
        next if /^\./;
        say "Found a task $_!";
    }

    use Path::Class;

    my $meals = dir( 'tasks', 'cooking' );
    my $file  = file( 'tasks', 'health', 'robots.txt' );

    my $lunch      = $meals->file( 'veggie_calzone' );
    my $robots_dir = $robot_list->dir();

    my $dir_fh    = $dir->open();
    my $robots_fh = $robot_list->open( 'r' )
                        or die "Open failed: $!";

    my $contents = read_from_filename( "$lunch" );

    say 'Present!' if -e $filename;

    rename 'death_star.txt', 'carbon_sink.txt';

    # или если вы стильный:
    rename 'death_star.txt' => 'carbon_sink.txt';

Многие считают CPAN (CPAN) самой мощной возможностью Perl 5. CPAN, по сути, представляет собой систему для поиска и установки модулей. Модуль — это пакет, содержащийся в своём собственном файле, который можно загружать с помощью use или require. Модуль должен быть валидным кодом на Perl 5. Он должен завершаться выражением, возвращающим истинное значение, чтобы парсер Perl 5 мог понять, что он успешно загрузил и скомпилировал модуль. Других требований нет, только твёрдые соглашения.

Когда вы загружаете модуль, Perl разбивает имя пакета по двойным двоеточиям (::) и превращает компоненты имени пакета в имя файла. На практике, use StrangeMonkey; заставляет Perl искать файл с именем StrangeMonkey.pm во всех директориях, входящих в @INC, по порядку, пока он его не найдёт или не израсходует список.

Аналогично, use StrangeMonkey::Persistence; заставляет Perl искать файл с именем Persistence.pm в каждой директории с именем StrangeMonkey/, находящейся в любой из директорий, входящих в @INC, и т. д. use StrangeMonkey::UI::Mobile; заставляет Perl искать относительный файловый путь StrangeMonkey/UI/Mobile.pm в каждой директории в @INC.

Результирующий файл может содержать или не содержать объявление пакета, совпадающее с именем файла — такого технического требования нет — но вопросы поддержки рекомендуют это соглашение.

perldoc -l Module::Name выведет полный путь к соответствующему файлу .pm, в случае, если документация к этому модулю существует в файле .pm. perldoc -lm Module::Name выведет полный путь к файлу .pm, независимо от существования параллельного файла .pod. perldoc -m Module::Name отобразит содержимое файла .pm.

Использование и импортирование

Когда вы загружаете модуль с помощью use, Perl загружает его с диска, а затем вызывает его метод import(), передавая все указанные вами аргументы. По соглашению метод import() модуля принимает список имён и экспортирует функции и другие символы в вызывающее пространство имён. Это всего лишь соглашение; модуль может отказаться предоставлять import(), или его import() может выполнять другие действия. Прагмы (Прагмы), такие как strict, используют аргументы для изменения поведения вызывающей лексической области видимости вместо экспорта символов:

    use strict;
    # …вызывает strict->import()

    use CGI ':standard';
    # …вызывает CGI->import( ':standard' )

    use feature qw( say switch );
    # …вызывает feature->import( qw( say switch ) )

Встроенная директива no вызывает метод unimport() модуля, если он существует, передавая любые аргументы. Это наиболее распространено с прагмами, использование которых модифицирует поведение через import():

    use strict;
    # запрещены символьные ссылки или голые слова
    # требуется объявление переменных

    {
        no strict 'refs';
        # символьные ссылки разрешены
        # ограничения 'subs' и 'vars' всё ещё активны
    }

И use, и no действуют во время компиляции, так что:

    use Module::Name qw( list of arguments );

…это то же самое, что:

    BEGIN
    {
        require 'Module/Name.pm';
        Module::Name->import( qw( list of arguments ) );
    }

Аналогично:

    no Module::Name qw( list of arguments );

…это то же самое, что:

    BEGIN
    {
        require 'Module/Name.pm';
        Module::Name->unimport(qw( list of arguments ));
    }

…включая require модуля.

Если import() или unimport() не существует в модуле, Perl не будет выдавать сообщение об ошибке. Они совершенно опциональны.

Вы можете вызвать import() и unimport() напрямую, хотя за пределами блока BEGIN делать это мало смысла; после завершения компиляции действие import() или unimport() может не иметь особого эффекта.

В Perl 5 use и require регистрозависимы, хотя, в то время как Perl понимает разницу между strict и Strict, ваше сочетание операционной системы и файловой системы может не знать. Если бы вы написали use Strict;, Perl не нашёл бы strict.pm в регистрозависимых файловых системах. В регистронезависимых файловых системах Perl охотно загрузит Strict.pm, но когда он попытается вызвать Strict->import(), ничего не случится. (strict.pm объявляет пакет с именем strict.)

Переносимые программы придерживаются строгих правил относительно этого случая, даже если и не обязаны.

Экспортирование

    package StrangeMonkey::Utilities;

    use Exporter 'import';

    our @EXPORT_OK = qw( round translate screech );

    ...

    push @EXPORT_OK, qw( $spider $saki $squirrel );

    our @EXPORT = qw( monkey_dance monkey_sleep );

    # сделать модуль доступным, но ничего не импортировать
    use StrangeMonkey::Utilities ();

    StrangeMonkey::Utilities::screech();

Самый простой способ управлять конфигурацией, сборкой, упаковкой, тестированием и установкой программного обеспечения — следовать соглашениям CPAN-дистрибутивов. Дистрибутив — это набор метаданных и одного или нескольких модулей (Модули), формирующих одну пригодную для распространения, тестирования и установки единицу.

Все эти руководства — как упаковать дистрибутив, как разрешать его зависимости, куда устанавливать программное обеспечение, как проверять, что оно работает, как отображать документацию, как управлять репозиторием — родились из примерного консенсуса тысяч контрибуторов, работающих над десятками тысяч проектов. Дистрибутив, построенный по стандартам CPAN, может быть протестирован на нескольких версиях Perl 5 на нескольких разных аппаратных платформах в течение нескольких часов после загрузки, при этом об ошибках будет автоматически сообщено авторам — и всё это без вмешательства человека.

Вы можете никогда не выпускать свой код как публичные CPAN-дистрибутивы, но вы можете использовать инструменты и соглашения CPAN даже для управления частным кодом. Сообщество Perl построило восхитительную инфраструктуру; почему бы ей не воспользоваться?

Характеристики дистрибутива

Помимо одного или нескольких модулей, дистрибутив включает несколько других файлов и директорий:

• Build.PL или Makefile.PL, программа-драйвер, используемая для конфигурации, сборки, тестирования, компоновки и установки дистрибутива.
• MANIFEST, список всех файлов, входящих в дистрибутив. Это помогает инструментам удостовериться, что комплект полон.
• META.yml и/или META.json, файл, содержащий метаданные о дистрибутиве и его зависимостях.
• README, описание дистрибутива, его предназначения, его авторских прав и информации о лицензии.
• lib/, директория, в которой содержатся Perl-модули.
• t/, директория, в которой содержатся файлы тестов.
• Changes, лог каждого изменения дистрибутива.

Правильно построенный дистрибутив должен содержать уникальное имя и единый номер версии (который часто берётся из его основного модуля). Любой дистрибутив, который вы скачаете из публичной CPAN, должен соответствовать этим стандартам. Публичный сервис CPANTS (http://cpants.perl.org/) проверяет каждый загруженный модуль по руководствам и соглашениям сборки и рекомендует улучшения. Следование руководствам CPANTS не означает, что код работает, но означает, что инструменты сборки CPAN должны понять дистрибутив.

Инструменты CPAN для управления дистрибутивами

Ядро Perl 5 включает несколько инструментов для установки, разработки и управления вашими собственными дистрибутивами:

• CPAN.pm — официальный CPAN-клиент; CPANPLUS — альтернатива. Они в основном аналогичны. Хотя по умолчанию эти клиенты устанавливают дистрибутивы из публичной CPAN, вы можете вместо или дополнительно к этому направить их на свой собственный репозиторий.
• Module::Build — это написанный на чистом Perl набор инструментов для конфигурирования, сборки, установки и тестирования дистрибутивов. Он работает с файлами Build.PL.
• ExtUtils::MakeMaker — это унаследованный инструмент, на замену которому предназначен Module::Build. Он всё ещё широко используется, хотя находится в режиме поддержки и получает только критические исправления ошибок. Он работает с файлами Makefile.PL.
• Test::More (Тестирование) — базовый и самый широко используемый модуль тестирования, предназначенный для написания автоматизированных тестов для программного обеспечения на Perl.
• Test::Harness и prove (Запуск тестов) запускают тесты и интерпретируют и генерируют отчёты по их результатам.

В дополнение к этому, несколько дополнительных CPAN-модулей сделают легче вашу жизнь как разработчика:

• App::cpanminus — это не требующий конфигурации CPAN-клиент. Он обрабатывает наиболее распространённые случаи, использует мало памяти и быстро работает.
• App::perlbrew помогает вам управлять несколькими инсталляциями Perl 5. Установите новые версии Perl 5 для тестирования или производственной среды, или чтобы изолировать приложения и их зависимости.
• CPAN::Mini и комманда cpanmini позволяют вам создать своё собственное (частное) зеркало публичной CPAN. Вы можете ввести в этот репозиторий свои собственные дистрибутивы и управлять тем, какие версии публичных модулей доступны в вашей организации.
• Dist::Zilla автоматизирует наиболее распространённые задачи распространения дистрибутивов. Хотя он использует либо Module::Build, либо ExtUtils::MakeMaker, он может заменить ваше использование их напрямую. Смотрите интерактивное руководство по адресу http://dzil.org/.
• Test::Reporter позволяет вам выводить отчёты по результатам запуска набора автоматизированных тестов дистрибутивов, которые вы устанавливаете, давая их авторам больше данных о сбоях.

Проектирование дистрибутивов

Описание процесса проектирования дистрибутива может занять целую книгу (см. Writing Perl Modules for CPAN Сэма Трегара (Sam Tregar)), но несколько принципов дизайна помогут вам. Начните с такой утилиты как Module::Starter или Dist::Zilla. Начальная стоимость изучения конфигурации и правил может выглядеть как чрезмерная инвестиция, но преимущества того, что всё будет правильно настроено (и в случае Dist::Zilla никогда не устареет) освобождает вас от намного более утомительной бухгалтерии.

Затем рассмотрите несколько правил:

• Каждый дистрибутив должен иметь единственное, чётко определённое предназначение. Этим предназначением может быть даже сборка нескольких связанных дистрибутивов в один устанавливаемый комплект. Декомпозиция вашего программного обеспечения на отдельные дистрибутивы позволяет вам соответственно управлять их зависимостями и соблюдать их инкапсуляцию.
• Каждый дистрибутив должен иметь единственный номер версии. Номера версий всегда должны увеличиваться. Политика семантических версий (http://semver.org/) разумна и совместима с подходом Perl 5.
• Каждый дистрибутив требует хорошо определённого API. Всесторонний автоматизированный набор тестов может проверить, что вы поддерживаете этот API между версиями. Если вы используете локальное зеркало CPAN для установки своих собственных дистрибутивов, вы можете использовать инфраструктуру CPAN для тестирования дистрибутивов и их зависимостей. Вы получите лёгкий доступ к интеграционному тестированию пригодных к повторному использованию компонентов.
• Автоматизируйте тесты вашего дистрибутива и сделайте их повторяемыми и ценными. Инфраструктура CPAN поддерживает отчёты автоматизированного тестирования. Используйте это!
• Предоставьте эффективный и простой интерфейс. Избегайте использования глобальных символов и экспорта по умолчанию; позвольте людям использовать только то, что им нужно. Не загрязняйте их пространства имён.

Пакет UNIVERSAL

Встроенный пакет UNIVERSAL в Perl 5 — предок всех остальных пакетов — в объектно-ориентированном смысле (Moose). UNIVERSAL предоставляет несколько методов, которые его потомки могут унаследовать или переопределить.

Метод isa()

Метод isa() принимает строку, содержащую имя класса или имя встроенного типа. Вызывайте его как метод класса или метод экземпляра на объекте. Он возвращает истинное значение, если его инвокант является указанным классом или происходит от него, или если инвокант — благословлённая ссылка на заданный тип.

Пусть есть объект $pepper (ссылка на хеш, благословлённая в класс Monkey, наследующий от класса Mammal), тогда:

    say $pepper->isa( 'Monkey'  );  # выводит 1
    say $pepper->isa( 'Mammal'  );  # выводит 1
    say $pepper->isa( 'HASH'    );  # выводит 1
    say Monkey->isa(  'Mammal'  );  # выводит 1

    say $pepper->isa( 'Dolphin' );  # выводит 0
    say $pepper->isa( 'ARRAY'   );  # выводит 0
    say Monkey->isa(  'HASH'    );  # выводит 0

Встроенные типы Perl 5 — SCALAR, ARRAY, HASH, Regexp, IO и CODE.

Любой класс может переопределить isa(). Это может быть полезно при работе с объектами-моками (см. Test::MockObject и Test::MockModule в CPAN) или с кодом, не использующим ролей (Роли). Имейте ввиду, что любой класс, переопределяющий isa(), обычно имеет для этого хорошую причину.

Метод can()

Метод can() принимает строку, содержащую имя метода. Он возвращает ссылку на функцию, имплементирующую этот метод, если она существует. В противном случае он возвращает ложное значение. Вы можете вызвать его на классе, объекте или имени пакета. В последнем случае он возвращает ссылку на функцию, а не метод (footnote: …не то чтобы вы могли определить разницу, имея только ссылку.).

Хотя и UNIVERSAL::isa(), и UNIVERSAL::can() — методы (Эквивалентность методов и функций), вы можете безопасно использовать последний как функцию единственно для определения, существует ли класс в Perl 5. Если UNIVERSAL::can( $classname, 'can' ) возвращает истинное значение, кто-то где-то определил класс с именем $classname. Этот класс может быть непригодным к использованию, но он существует.

Имея класс, названный SpiderMonkey, с методом, названным screech, получить ссылку на метод можно так:

    if (my $meth = SpiderMonkey->can( 'screech' )) {...}

    if (my $meth = $sm->can( 'screech' )
    {
        $sm->$meth();
    }

Используйте can() чтобы проверить, что класс имплементирует конкретную функцию или метод:

    use Class::Load;

    die "Couldn't load $module!"
        unless load_class( $module );

    if (my $register = $module->can( 'register' ))
    {
        $register->();
    }

В то время как CPAN-модуль Class::Load упрощает работу по загрузке классов по имени — вместо танцев с require — Module::Pluggable выполняет большую часть работы по сборке и управлению системой плагинов. Ознакомьтесь с обоими дистрибутивами.

Метод VERSION()

Метод VERSION возвращает значение переменной $VERSION соответствующего пакета или класса. Если вы укажете номер версии как необязательный параметр, метод выбросит исключение, если опрашиваемая $VERSION не равна или больше чем параметр.

Пусть есть модуль HowlerMonkey версии 1.23, тогда:

    say HowlerMonkey->VERSION();    # выводит 1.23
    say $hm->VERSION();             # выводит 1.23
    say $hm->VERSION( 0.0  );       # выводит 1.23
    say $hm->VERSION( 1.23 );       # выводит 1.23
    say $hm->VERSION( 2.0  );       # исключение!

Нет особых причин переопределять VERSION().

Метод DOES()

Метод DOES() появился в Perl 5.10.0. Он существует для поддержки использования в программах ролей (Роли). Передайте ему инвокант и имя роли, и метод вернёт истинное значение, если соответствующий класс как-либо выполняет эту роль — будь то через наследование, делегирование, композицию, применение роли или любой другой механизм.

По умолчанию реализация DOES откатывается к isa(), потому что наследование — единственный механизм, с помощью которого класс может выполнять роль. Пусть есть Cappuchin:

    say Cappuchin->DOES( 'Monkey'       );  # выводит 1
    say $cappy->DOES(    'Monkey'       );  # выводит 1
    say Cappuchin->DOES( 'Invertebrate' );  # выводит 0

Переопределите DOES(), если вы вручную предоставляете роль или предоставляете другое алломорфичное поведение.

Расширение UNIVERSAL

Возникает соблазн сохранять в UNIVERSAL другие методы, чтобы сделать их доступными для всех других классов и объектов в Perl 5. Избегайте этого соблазна; это глобальное поведение можеть иметь неочевидные побочные эффекты, потому что оно не ограничено.

Учитывая сказанное, редкое злоупотребление UNIVERSAL для целей отладки и для исправления неправильного поведения по умолчанию можеть быть извинено. Например, дистрибутив UNIVERSAL::ref Джошуа бен Джоре (Joshua ben Jore) делает практически бесполезный оператор ref() полезным. Дистрибутивы UNIVERSAL::can и UNIVERSAL::isa могут помочь вам отладить анти-полиморфные баги (Эквивалентность методов и функций). Perl::Critic может обнаружить эти и другие проблемы.

За пределами очень осторожно контролируемого кода и очень специфичных, очень прагматичных ситуаций, нет причин напрямую помещать код в UNIVERSAL. Почти всегд есть намного лучшие альтернативы дизайна.

Кодогенерация

Написание программ, пишуших для вас программы — метапрограммирование или кодогенерация — предлагает большие возможности для абстракции. Хотя вы можете устроить огромный бардак, но вы можете и создать изумительные вещи. Например, техники метапрограммирования делают возможным Moose (Moose):

Техника использования AUTOLOAD (AUTOLOAD) для отсутствующих функций и методов демонстрирует эту технику в ограниченной форме; система диспетчеризации функций и методов в Perl 5 позволяет вам настроить, что происходит, когда нормальный поиск проваливается.

eval

Самая простая техника кодогенерации — это формирование строки, содержащей фрагмент валидного кода на Perl, и компиляция её с помощью строкового оператора eval. В отличие от отлавливающего исключения блочного оператора eval, строковый eval компилирует содержимое строки в текущей области видимости, включая текущий пакет и лексические привязки.

Наиболее общее использование этой техники — предоставление возможности отката, если вы не можете (или не хотите) загружать опциональную зависимость:

    eval { require Monkey::Tracer }
        or eval 'sub Monkey::Tracer::log {}';

Если Monkey::Tracer недоступен, его функция log() будет существовать, но ничего не будет делать. Однако этот простой пример обманчив. Правильное использование eval требует определённой работы; вы должны обработать проблемы заключения в кавычки для включения переменных в передаваемый в eval код. Добавьте сложности чтобы интерполировать одни переменные, но не другие:

    sub generate_accessors
    {
        my ($methname, $attrname) = @_;

        eval <<"END_ACCESSOR";
        sub get_$methname
        {
            my \$self = shift;
            return \$self->{$attrname};
        }

        sub set_$methname
        {
            my (\$self, \$value) = \@_;
            \$self->{$attrname}  = \$value;
        }
    END_ACCESSOR
    }

Горе тем, кто забыл обратный слеш! Удачи в объяснении вашей подсветке синтаксиса, что происходит! Хуже того, каждый вызов строкового eval создаёт новую структуру данных, представляющую код целиком, и компиляция кода тоже не бесплатна. Но даже с этими ограничениями эта техника проста.

Параметризованные замыкания

Хотя построение аксессоров и мутаторов с помощью eval просто, замыкания (Замыкания) позволяют вам добавлять параметры в генерируемый код во время компиляции без необходимости дополнительного вычисления:

    sub generate_accessors
    {
        my $attrname = shift;

        my $getter = sub
        {
            my $self = shift;
            return $self->{$attrname};
        };

        my $setter = sub
        {
            my ($self, $value) = @_;
            $self->{$attrname} = $value;
        };

        return $getter, $setter;
    }

Этот код избегает неприятных проблем с заключением в кавычки и компилирует каждое замыкание только один раз. Он даже использует меньше памяти из-за разделения скомпилированного кода между всеми экземплярами замыканий. Всё, что различается — это привязка к лексической переменной $attrname. В долго выполняющихся процессах, или при большом количестве аксессоров, эта техника может быть очень полезна.

Установка в таблицу символов относительно проста, хоть и некрасива:

    {
        my ($get, $set) = generate_accessors( 'pie' );

        no strict 'refs';
        *{ 'get_pie' } = $get;
        *{ 'set_pie' } = $set;
    }

Странный синтаксис звёздочки (footnote: Воспринимайте её как сигил тайпглоба, где тайпглоб — Perl-жаргон для «таблицы символов».) разыменовывает хеш, ссылающийся на символ в текущей таблице символов, являющейся частью текущего пространства имён, содержащего глобально-доступные символы, такие как глобальные данные пакета, функции и методы. Присваивание ссылки записи таблицы символов устанавливает или заменяет соответствующую запись. Чтобы повысить анонимную функцию до метода, сохраните ссылку на эту функцию в таблице символов.

CPAN-модуль Package::Stash предлагает более приятный интерфейс для подобного хакинга таблицы символов.

Присваивание таблице символов символа, содержащего строку, не литеральное имя переменной, это символическая ссылка. Для этой операции вам нужно отключить строгую проверку ссылок strict. Многие программы имеют неочевидный баг в аналогичном коде, так как они присваивают и генерируют в одной строчке:

    {
        no strict 'refs';

        *{ $methname } = sub {
            # неочевидный баг: strict refs отключено здесь тоже
        };
    }

Этот пример отключает ограничения для внешнего блока, так же как и для тела самой функции. Только присваивание нарушает строгую проверку ссылок, так что отключайте ограничения только для этой операции.

Если имя метода — строковый литерал в вашем исходном коде, а не содержимое переменной, вы можете присвоить соответсвующему символу напрямую:

    {
        no warnings 'once';
        (*get_pie, *set_pie) =
             generate_accessors( 'pie' );
    }

Прямое присваивание глобу не нарушает ограничения, но упоминание глоба только раз будет генерировать предупреждение «used only once», если вы явно не подавите его в области видимости.

Манипуляции времени компиляции

В отличие от кода, написанного явно как код, код, генерируемый с помощью строкового eval, компилируется во время выполнения. Там, где вы можете ожидать от нормальной функции, что она будет доступна всё время жизни программы, сгенерированная функция может не быть доступной, когда вы этого ожидаете.

Заставьте Perl выполнять код — генерирующий другой код — во время компиляции, обернув его в блок BEGIN. Когда парсер Perl 5 встречает блок BEGIN, он парсит весь блок. Если он не содержит синтаксических ошибок, блок будет выполнен немедленно. После его завершения парсинг продолжится, как если бы не было никаких прерываний.

Разница между записью:

    sub get_age    { ... }
    sub set_age    { ... }

    sub get_name   { ... }
    sub set_name   { ... }

    sub get_weight { ... }
    sub set_weight { ... }

…и:

    sub make_accessors { ... }

    BEGIN
    {
        for my $accessor (qw( age name weight ))
        {
            my ($get, $set) =
                make_accessors( $accessor );

            no strict 'refs';
            *{ 'get_' . $accessor } = $get;
            *{ 'set_' . $accessor } = $set;
        }
    }

…преимущественно в поддерживаемости.

Внутри модуля, любой код за пределами функций выполняется, когда вы используете его посредством use, из-за неявного BEGIN, который Perl добавляет вокруг require и import (Импорт). Любой код за пределами функций, но внутри модуля, будет выполнен перед тем, как произойдёт вызов import(). Если вы загружаете модуль с помощью require, неявного блока BEGIN не будет. Выполнение кода за пределами функций произойдёт в конце парсинга.

Учитывайте взаимодействие между лексическими объявлениями (ассоциирование имени с областью видимости) и лексическими присваиваниями. Первые происходят во время компиляции, тогда как последние происходят в точке выполнения. Этот код имеет неочевидный баг:

    # добавляет метод require() в UNIVERSAL
    use UNIVERSAL::require;

    # ведёт к ошибкам; не использовать
    my $wanted_package = 'Monkey::Jetpack';

    BEGIN
    {
        $wanted_package->require();
        $wanted_package->import();
    }

…потому что блок BEGIN будет выпволнен перед тем, как произойдёт присваивание строкового значения $wanted_package. Результатом будет исключение из-за попытки вызвать метод require() на неопределённом значении.

Class::MOP

    use Class::MOP;

    my $class = Class::MOP::Class->create(
                    'Monkey::Wrench'
                );

    my $class = Class::MOP::Class->create(
        'Monkey::Wrench' =>
        (
            attributes =>
            [
                Class::MOP::Attribute->new('$material'),
                Class::MOP::Attribute->new('$color'),
            ]
            methods =>
            {
                tighten => sub { ... },
                loosen  => sub { ... },
            }
        ),
    );

    $class->add_attribute(
        experience  => Class::MOP::Attribute->new('$xp')
    );

    $class->add_method( bash_zombie => sub { ... } );

    my @attrs = $class->get_all_attributes();
    my @meths = $class->get_all_methods();

    package Null
    {
        use overload 'bool' => sub { 0 };

        ...
    }

    package Null
    {
        use overload
            'bool' => sub { 0 },
            '""'   => sub { '(null)' };
    }

Переопределение преобразования в число более сложно, потому что арифметические операторы имеют тенденцию быть бинарными (Арность). Если есть два оператора, оба с перегруженными методами для сложения, какой будет приоритетнее? Ответ должен быть последовательным, простым для объяснения и понятным людям, которые не читали исходный код реализации.

perldoc overload пытается объяснить это в разделах Calling Conventions for Binary Operations и MAGIC AUTOGENERATION, но наиболее простое решение — перегрузить преобразование в число (имеющее ключ '0+') и указать overload использовать предоставленные перегрузки как запасной вариант (fallback) где возможно:

    package Null
    {
        use overload
            'bool'   => sub { 0 },
            '""'     => sub { '(null)' },
            '0+'     => sub { 0 },
            fallback => 1;
    }

Установка fallback в истинное значение позволяет Perl использовать любые другие определённые перегрузки для выполнения запрошенной операции, если возможно. Если это невозможно, Perl будет действовать так, как если бы не было никаких перегрузок. Это часто именно то, чего вы хотите.

Без fallback Perl будет использовать только конкретные перегрузки, которые вы предоставили. Если кто-нибудь попытается выполнить операцию, которую вы не перегрузили, Perl выбросит исключение.

Перегрузка и наследование

Подклассы наследуют перегрузки от своих предков. Они могут переопределить это поведение одним из двух способов. Если родительский класс использует перегрузку как показано, с напрямую предоставленными ссылками на функции, класс-потомок должен переопределить перегруженное поведение родителя с помощью прямого использования overload.

Родительские классы могут позволить своим потомкам большую гибкость, указывая имя метода для вызова в качестве реализации перегрузки, вместо хардкода ссылки на функцию:

    package Null
    {
        use overload
            'bool'   => 'get_bool',
            '""'     => 'get_string',
            '0+'     => 'get_num',
            fallback => 1;
    }

В этом случае любые дочерние классы могут выполнять эти перегруженные операции иначе, переопределив методы с соответствующими именами.

Использование перегрузки

Перегрузка может выглядеть заманчивым инструментом для использования для генерации символьных сокращений для новых операций, но это редко происходит в Perl 5 по весомым причинам. CPAN-дистрибутив IO::All доводит эту идею до предела в производстве умных идей для краткого и компонуемого кода. Однако на каждый блестящий API, доведённый до совершенства путём соответствующего использования перегрузки, дюжина других устраивают бардак. Иногда лучший код избегает умности в пользу простоты.

Переопределение сложения, умножения и даже конкатенации в классе Matrix имеет смысл только из-за того, что распространена существующая нотация для этих операций. Новая предметная область, не имеющая такой установившейся нотации — плохой кандидат для перегрузки, как и предметная область, в которой вам приходится изощряться, чтобы поставить существующие операторы Perl в соответствие с другой нотацией.

Perl Best Practices Демьена Конвея (Damian Conway) предлагают другое использование перегрузки: для предотвращения случайного неправильного использования объектов. Например, перегрузка преобразования в число таким образом, чтобы она делала croak(), для объектов, не имеющих разумного представления в виде одного числа, может помочь вам найти и исправить реальные ошибки.

Испорченность

    die 'Oh no! Tainted data!'
        if Scalar::Util::tainted( $suspicious_value );

    die 'Number still tainted!'
        unless $number =~ /(\(/d{3}\) \d{3}-\d{4})/;

    my $safe_number = $1;

    delete @ENV{ qw( IFS CDPATH ENV BASH_ENV ) };
    $ENV{PATH} = '/path/to/app/binaries/';