NAME
    XML::LibXSLT::Processor - XSLT processor based on libxslt with
    additional features

SYNOPSIS
        use XML::LibXML;
        use XML::LibXSLT::Processor;

        my $xsltproc = XML::LibXSLT::Processor->new();
        my $xml = XML::LibXML->load_xml(location => 'foo.xml');
        my $result = $xsltproc->transform($xml, 'bar.xsl' => { param => 1 });
        print $result->output_string();

    Multi-pass transform:

        my $result = $xsltproc->transform($xml,
            'style1.xsl' => { param => 1 },
            'style2.xsl' => { param => 1 },
            ...
        );

DESCRIPTION
    This processor caches templates, documents and keys, which leads to the
    acceleration of the transformation, as well as much more.

    Transformation benchmark:

        Test small xml:
                                   Rate            XML::LibXSLT XML::LibXSLT::Processor
        XML::LibXSLT            14493/s                      --                    -35%
        XML::LibXSLT::Processor 22222/s                     53%                      --

        Test big xml:
                                 Rate            XML::LibXSLT XML::LibXSLT::Processor
        XML::LibXSLT            823/s                      --                     -3%
        XML::LibXSLT::Processor 851/s                      3%                      --

    Using the key() function:

        First run:
                                                 Rate Search by key (not cached) Search by key (cached) Sequential search
        Search by key (not cached)             20.0/s                         --                   -40%             -100%
        Search by key (cached)                 33.3/s                        67%                     --             -100%
        Sequential search                          --                         --                     --                --

        Second run:
                                      Rate Search by key (not cached) Sequential search Search by key (cached)
        Search by key (not cached)  31.5/s                         --              -88%                  -100%
        Sequential search            254/s                       706%                --                   -99%
        Search by key (cached)     20000/s                     63440%             7780%                     --

    Using the document() function:

                                  Rate XML::LibXSLT Processor (Not cached) Processor (Cached)
        XML::LibXSLT            7092/s           --                   -32%               -65%
        Processor (Not cached) 10417/s          47%                     --               -48%
        Processor (Cached)     20000/s         182%                    92%                 --

    Using profiler:

        my $xsltproc = XML::LibXSLT::Processor->new(
            profiler_enable => 1,
            profiler_repeat => 20,
        );
        my $result = $xsltproc->transform('t/files/test1.xml',
            't/files/multi-transform1.xsl' => { pass => "1" },
            't/files/multi-transform2.xsl' => { pass => "2" },
        );
        print $result->profiler_result->toString(2);

        <profiler repeat="20">
          <stylesheet uri="t/files/multi-transform1.xsl" time="196">
            <profile>
              <template rank="1" match="/" name="" mode="" calls="20" time="13" average="0"/>
            </profile>
            <document>
              <root>
                <pass1>1</pass1>
              </root>
            </document>
            <params>
              <param name="pass" value="1"/>
            </params>
          </stylesheet>
          <stylesheet uri="t/files/multi-transform2.xsl" time="221">
            <profile>
              <template rank="1" match="/" name="" mode="" calls="20" time="21" average="1"/>
            </profile>
            <document>
              <root>
                <prev_pass>1</prev_pass>
                <pass2>2</pass2>
              </root>
            </document>
            <params>
              <param name="pass" value="2"/>
            </params>
          </stylesheet>
        </profiler>

        Example of using profiler you can see in directory "examples/profiler".

METHODS
  new
        my $xsltproc = XML::LibXSLT::Processor->new(%options);

    Creates instance of the XSLT processor.

    Valid options are:

    *   stylesheet_max_depth [ = 250 ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                stylesheet_max_depth => 1000
            );

        This option sets the maximum recursion depth for a stylesheet.

    *   stylesheet_caching_enable [ = 1 ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                stylesheet_caching_enable => 1
            );

        Set this option to "1" to enable stylesheet caching.

    *   document_caching_enable [ = 1 ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                document_caching_enable => 1
            );

        Set this option to "1" to enable XML document caching.

    *   keys_caching_enable [ = 1 ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                keys_caching_enable => 1
            );

        Set this option to "1" to enable keys caching.

    *   profiler_enable [ = 0 ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                profiler_enable => 1
            );

        Set this option to "1" to enable collection the profile information.

    *   profiler_stylesheet [ = undef ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                profiler_stylesheet => 'profiler.xsl'
            );

        If parameter is specified, the profile information added with this
        template in the resulting HTML document.

    *   profiler_repeat [ = 1 ]

            my $xsltproc = XML::LibXSLT::Processor->new(
                profiler_repeat => 1
            );

        This option sets the number of repeats transformations.

  transform(xml, stylesheet => \%params, stylesheet => \%params, ...)
        my $xml = XML::LibXML->load_xml(location => 'foo.xml');
        my $result = $xsltproc->transform($xml, 'bar.xsl');
        print $result->output_string();

        my $result = $xsltproc->transform('foo.xml', 'bar.xsl' => { param => 1 });
        print $result->output_string();

        my $result = $xsltproc->transform('<root/>', 'bar.xsl' => { param => 1 });
        print $result->output_string();

        my $result = $xsltproc->transform('<root/>', 'bar.xsl' => { param => 1 }, 'bar.xsl' => { param => 2 });
        print $result->output_string();

    Transforms the passed in XML document, and returns
    XML::LibXSLT::Processor::Result.

    Paramaters are:

    *   xml

        XML document may be specified as an XML::LibXML::Document object, a
        file name or a string.

    *   stylesheet

        Stylesheet file name.

XSLT FUNCTIONS
    The namespace for XSLT functions is "http://xsltproc.org/xslt/string".

  str:join((node-set|string), ..., sep)
    Returns a string created by concatenating the string arguments and using
    the sep argument as the separator.

        Example: str:join('str1', 'str2', ' ')
        Result: 'str1 str2'

        Example: str:join('str1', /root/string, 'str4', ', ')
        XML: <root><string>str2</string><string>str3</string></root>
        Result: 'str1, str2, str3, str4'

  str:uc(string)
    Converts the string argument to upper-case.

  str:lc(string)
    Converts the string argument to lower-case.

  str:trim(string)
    Removes whitespaces and other predefined characters (\t, \r, \n) from
    both sides of a string.

  str:ltrim(string)
    Removes whitespaces and other predefined characters (\t, \r, \n) from
    the left side of a string.

  str:rtrim(string)
    Removes whitespaces and other predefined characters (\t, \r, \n) from
    the right side of a string.

AUTHOR
        Yuriy Ustushenko, <<yoreek@yahoo.com>>

COPYRIGHT AND LICENSE
    Copyright (C) 2013 Yuriy Ustushenko

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