NAME
    App::podsel - Select Pod::Elemental nodes using CSel syntax

VERSION
    This document describes version 0.007 of App::podsel (from Perl
    distribution App-podsel), released on 2020-04-14.

SYNOPSIS
FUNCTIONS
  podsel
    Usage:

     podsel(%args) -> [status, msg, payload, meta]

    Select Pod::Elemental nodes using CSel syntax.

    This function is not exported.

    Arguments ('*' denotes required arguments):

    *   expr => *str*

    *   file => *str* (default: "-")

    *   node_actions => *array[str]* (default: ["print_as_string"])

        Specify action(s) to perform on matching nodes.

        Each action can be one of the following:

        *   "count" will print the number of matching nodes.

        *   "print_method" will call on or more of the node object's methods
            and print the result. Example:

            print_method:as_string

        *   "dump" will show a indented text representation of the node and
            its descendants. Each line will print information about a single
            node: its class, followed by the value of one or more
            attributes. You can specify which attributes to use in a
            dot-separated syntax, e.g.:

            dump:tag.id.class

            which will result in a node printed like this:

            HTML::Element tag=p id=undef class=undef

        By default, if no attributes are specified, "id" is used. If the
        node class does not support the attribute, or if the value of the
        attribute is undef, then "undef" is shown.

        *   "eval" will execute Perl code for each matching node. The Perl
            code will be called with arguments: "($node)". For convenience,
            $_ is also locally set to the matching node. Example in htmlsel
            you can add this action:

            eval:'print $_->tag'

            which will print the tag name for each matching HTML::Element
            node.

    *   node_actions_on_descendants => *str* (default: "")

        Specify how descendants should be actioned upon.

        This option sets how node action is performed (See "node_actions"
        option).

        When set to '' (the default), then only matching nodes are actioned
        upon.

        When set to 'descendants_depth_first', then after each matching node
        is actioned upon by an action, the descendants of the matching node
        are also actioned, in depth-first order. This option is sometimes
        necessary e.g. when your node's "as_string()" method shows a node's
        string representation that does not include its descendants.

    *   select_action => *str* (default: "csel")

        Specify how we should select nodes.

        The default is "csel", which will select nodes from the tree using
        the CSel expression. Note that the root node itself is not included.
        For more details on CSel expression, refer to Data::CSel.

        "root" will return a single node which is the root node.

    *   transforms => *array[str]*

        Apply one or more Pod::Elemental::Transform's.

        TRANSFORMS

        First of all, by default, the "stock" Pod::Elemental parser will be
        generic and often not very helpful in parsing your typical POD (Perl
        5 variant) documents. You often want to add:

         -t Pod5 -t Nester

        or -5 for short, which is equivalent to the above. Except in some
        simple cases. See examples below.

        The following are available transforms:

        *   Pod5

        Equivalent to this:

         Pod::Elemental::Transformer::Pod5->new->transform_node($tree);

        *   Nester

        Equivalent to this:

         my $nester;
 
         $nester = Pod::Elemental::Transformer::Nester->new({
             top_selector      => Pod::Elemental::Selectors::s_command('head3'),
             content_selectors => [
                 Pod::Elemental::Selectors::s_command([ qw(head4) ]),
                 Pod::Elemental::Selectors::s_flat(),
             ],
         });
         $nester->new->transform_node($tree);
 
         $nester = Pod::Elemental::Transformer::Nester->new({
             top_selector      => Pod::Elemental::Selectors::s_command('head2'),
             content_selectors => [
                 Pod::Elemental::Selectors::s_command([ qw(head3 head4) ]),
                 Pod::Elemental::Selectors::s_flat(),
             ],
         });
         $nester->new->transform_node($tree);
 
         $nester = Pod::Elemental::Transformer::Nester->new({
             top_selector      => Pod::Elemental::Selectors::s_command('head1'),
             content_selectors => [
                 Pod::Elemental::Selectors::s_command([ qw(head2 head3 head4) ]),
                 Pod::Elemental::Selectors::s_flat(),
             ],
         });
         $nester->new->transform_node($tree);

        EXAMPLES

        Note: pmpath is a CLI utility that returns the path of a locally
        installed Perl module. It's distributed in App::PMUtils
        distribution.

        Select all head1 commands (only print the command lines and not the
        content):

         % podsel C<pmpath strict> 'Command[command=head1]'
         =head1 NAME
 
         =head1 SYNOPSIS
 
         =head1 DESCRIPTION
 
         =head1 HISTORY

        Select all head1 commands that contain "SYN" in them (only print the
        command lines and not the content):

         % podsel C<pmpath strict> 'Command[command=head1][content =~ /synopsis/i]'
         =head1 SYNOPSIS

        Select all head1 commands that contain "SYN" in them (but now also
        print the content; note now the use of the "Nested" class selector
        and the -5 flag to create a nested document tree instead of a flat
        one):

         % podsel -5 C<pmpath strict> 'Nested[command=head1][content =~ /synopsis/i]'
         =head1 SYNOPSIS
 
             use strict;
 
             use strict "vars";
             use strict "refs";
             use strict "subs";
 
             use strict;
             no strict "vars";

        List of head commands in POD of List::Util:

         % podsel C<pmpath List::Util> 'Command[command =~ /head/]'
         =head1 NAME
 
         =head1 SYNOPSIS
 
         =head1 DESCRIPTION
 
         =head1 LIST-REDUCTION FUNCTIONS
 
         =head2 reduce
 
         =head2 reductions
 
         ...
 
         =head1 KEY/VALUE PAIR LIST FUNCTIONS
 
         =head2 pairs
 
         =head2 unpairs
 
         =head2 pairkeys
 
         =head2 pairvalues
 
         ...

        List only key/value pair list functions and not list-reduction ones:

         % podsel -5 C<pmpath List::Util> 'Nested[command=head1][content =~ /pair/i] Nested[command=head2]' --print-method content
         pairs
         unpairs
         pairkeys
         pairvalues
         pairgrep
         pairfirst
         pairmap

    Returns an enveloped result (an array).

    First element (status) is an integer containing HTTP status code (200
    means OK, 4xx caller error, 5xx function error). Second element (msg) is
    a string containing error message, or 'OK' if status is 200. Third
    element (payload) is optional, the actual result. Fourth element (meta)
    is called result metadata and is optional, a hash that contains extra
    information.

    Return value: (any)

HOMEPAGE
    Please visit the project's homepage at
    <https://metacpan.org/release/App-podsel>.

SOURCE
    Source repository is at <https://github.com/perlancar/perl-App-podsel>.

BUGS
    Please report any bugs or feature requests on the bugtracker website
    <https://rt.cpan.org/Public/Dist/Display.html?Name=App-podsel>

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

SEE ALSO
AUTHOR
    perlancar <perlancar@cpan.org>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2020, 2019 by perlancar@cpan.org.

    This is free software; you can redistribute it and/or modify it under
    the same terms as the Perl 5 programming language system itself.

