File Coverage

blib/lib/PPIx/Regexp.pm

Criterion	Covered	Total	%
statement	117	119	98.3
branch	41	50	82.0
condition	12	12	100.0
subroutine	29	30	96.6
pod	18	18	100.0
total	217	229	94.7

=head1 NAME

PPIx::Regexp - Represent a regular expression of some sort

=head1 SYNOPSIS

 use PPIx::Regexp;
 use PPIx::Regexp::Dumper;
 my $re = PPIx::Regexp->new( 'qr{foo}smx' );
 PPIx::Regexp::Dumper->new( $re )
     ->print();

=head1 DEPRECATION NOTICE

The C argument to L is retracted, and
postfix dereferences are always be recognized.

Starting with version 0.074_01, the first use of this argument warned.
With version 0.079_01, all uses warned. With version 0.080_01,
all uses became fatal. With version 0.084_01, all mention of this
argument was removed, except for this notice.

=head1 INHERITANCE

C is a L.

C has no descendants.

=head1 DESCRIPTION

The purpose of the F package is to parse regular
expressions in a manner similar to the way the L package parses
Perl. This class forms the root of the parse tree, playing a role
similar to L.

This package shares with L the property of being round-trip
safe. That is,

 my $expr = 's/ ( \d+ ) ( \D+ ) /$2$1/smxg';
 my $re = PPIx::Regexp->new( $expr );
 print $re->content() eq $expr ? "yes\n" : "no\n"

should print 'yes' for any valid regular expression.

Navigation is similar to that provided by L. That is to say,
things like C, C, C and so on all
work pretty much the same way as in L.

The class hierarchy is also similar to L. Except for some
utility classes (the dumper, the lexer, and the tokenizer) all classes
are descended from L, which
provides basic navigation. Tokens are descended from
L, which provides content. All
containers are descended from L,
which provides for children, and all structure elements are descended
from L, which provides
beginning and ending delimiters, and a type.

There are two features of L that this package does not provide
- mutability and operator overloading. There are no plans for serious
mutability, though something like L's C functionality
might be considered. Similarly there are no plans for operator
overloading, which appears to the author to represent a performance hit
for little tangible gain.

=head1 NOTICE

The author will attempt to preserve the documented interface, but if the
interface needs to change to correct some egregiously bad design or
implementation decision, then it will change.  Any incompatible changes
will go through a deprecation cycle.

The goal of this package is to parse well-formed regular expressions
correctly. A secondary goal is not to blow up on ill-formed regular
expressions. The correct identification and characterization of
ill-formed regular expressions is B a goal of this package, nor is
the consistent parsing of ill-formed regular expressions from release to
release.

This policy attempts to track features in development releases as well
as public releases. However, features added in a development release and
then removed before the next production release B be tracked,
and any functionality relating to such features B. The
issue here is the potential re-use (with different semantics) of syntax
that did not make it into the production release.

From time to time the Perl regular expression engine changes in ways
that change the parse of a given regular expression. When these changes
occur, C will be changed to produce the more modern parse.
Known examples of this include:

=over

=item C<$(> no longer interpolates as of Perl 5.005, per C.

Newer Perls seem to parse this as C (i.e. an end-of-string or
newline assertion) followed by an open parenthesis, and that is what
C does.

=item C<$)> and C<$|> also seem to parse as the C<$> assertion

followed by the relevant meta-character, though I have no documentation
reference for this.

=item C<@+> and C<@-> no longer interpolate as of Perl 5.9.4

per C. Subsequent Perls treat C<@+> as a quantified
literal and C<@-> as two literals, and that is what C
does. Note that subscripted references to these arrays B
interpolate, and are so parsed by C.

=item Only space and horizontal tab are whitespace as of Perl 5.23.4

when inside a bracketed character class inside an extended bracketed
character class, per C. Formerly any white space
character parsed as whitespace. This change in C will be
reverted if the change in Perl does not make it into Perl 5.24.0.

=item Unescaped literal left curly brackets

These are being removed in positions where quantifiers are legal, so
that they can be used for new functionality. Some of them are gone in
5.25.1, others will be removed in a future version of Perl. In
situations where they have been removed,
L
will return the version in which they were removed. When the new
functionality appears, the parse produced by this software will reflect
the new functionality.

B that the situation with a literal left curly after a literal
character is complicated. It was made an error in Perl 5.25.1, and
remained so through all 5.26 releases, but became a warning again in
5.27.1 due to its use in GNU Autoconf. Whether it will ever become
illegal again is not clear to me based on the contents of
F. At the moment
L
returns C, but obviously that is not the whole story, and methods
L and
L
were introduced to deal with this complication.

=item C<\o{...}>

is parsed as the octal equivalent of C<\x{...}>. This is its meaning as
of perl 5.13.2. Before 5.13.2 it was simply literal C<'o'> and so on.

=item C

(with first count omitted) is allowed as a quantifier as of Perl 5.33.6.
The previous parse made this all literals.

=item C

(with spaces inside but adjacent to curly brackets, or around the comma
if any) is allowed as a quantifier as of Perl 5.33.6. The previous parse
made this all literals.

=back

There are very probably other examples of this. When they come to light
they will be documented as producing the modern parse, and the code
modified to produce this parse if necessary.

=head1 METHODS

This class provides the following public methods. Methods not documented
here are private, and unsupported in the sense that the author reserves
the right to change or remove them without notice.

=cut

package PPIx::Regexp;

use strict;
use warnings;

use base qw{ PPIx::Regexp::Node };

use Carp;
use PPIx::Regexp::Constant qw{
    ARRAY_REF
    LOCATION_LINE
    LOCATION_CHARACTER
    LOCATION_COLUMN
    LOCATION_LOGICAL_LINE
    LOCATION_LOGICAL_FILE
    @CARP_NOT
};
use PPIx::Regexp::Lexer ();
use PPIx::Regexp::Token::Modifier ();	# For its modifier manipulations.
use PPIx::Regexp::Tokenizer;
use PPIx::Regexp::Util qw{
    __choose_tokenizer_class
    __instance
};
use Scalar::Util qw{ refaddr };

our $VERSION = '0.087_01';

=head2 new

 my $re = PPIx::Regexp->new('/foo/');

This method instantiates a C object from a string, a
L, a
L, or a
L.
Honestly, any L will work, but only the three
Regexp classes mentioned previously are likely to do anything useful.

Whatever form the argument takes, it is assumed to consist entirely of a
valid match, substitution, or C<< qr<> >> string.

Optionally you can pass one or more name/value pairs after the regular
expression. The possible options are:

=over

=item default_modifiers array_reference

This option specifies a reference to an array of default modifiers to
apply to the regular expression being parsed. Each modifier is specified
as a string. Any actual modifiers found supersede the defaults.

When applying the defaults, C<'?'> and C<'/'> are completely ignored,
and C<'^'> is ignored unless it occurs at the beginning of the modifier.
The first dash (C<'-'>) causes subsequent modifiers to be negated.

So, for example, if you wish to produce a C object
representing the regular expression in

 use re '/smx';
 {
    no re '/x';
    m/ foo /;
 }

you would (after some help from L in finding the relevant
statements), do something like

 my $re = PPIx::Regexp->new( 'm/ foo /',
     default_modifiers => [ '/smx', '-/x' ] );

=item encoding name

This option specifies the encoding of the regular expression. This is
passed to the tokenizer, which will C the regular expression
string before it tokenizes it. For example:

 my $re = PPIx::Regexp->new( '/foo/',
     encoding => 'iso-8859-1',
 );

=item index_locations Boolean

This Boolean option specifies whether the locations of the elements in
the regular expression should be indexed.

If unspecified or specified as C a default value is used. This
default is true if the argument is a L or the
C option was specified. Otherwise the default is false.

=item location array_reference

This option specifies the location of the new object in the document
from which it was created. It is a reference to a five-element array
compatible with that returned by the C method of
L.

If not specified, the location of the original string is used if it was
specified as a L.

If no location can be determined, the various C methods will
return C.

=item postderef Boolean

B.
See L above for the details.

This option is passed on to the tokenizer, where it specifies whether
postfix dereferences are recognized in interpolations and code. This
experimental feature was introduced in Perl 5.19.5.

As of version 0.074_01, the default is true.  Through release 0.074, the
default was the value of
C<$PPIx::Regexp::Tokenizer::DEFAULT_POSTDEREF>, which was true. When
originally introduced this was false, but was documented as becoming
true when and if postfix dereferencing became mainstream. The  intent to
mainstream was announced with Perl 5.23.1, and became official (so to
speak) with Perl 5.24.0, so the default became true with L
0.049_01.

Note that if L starts unconditionally recognizing postfix
dereferences, this argument will immediately become ignored, and will be
put through a deprecation cycle and removed.

=item strict Boolean

This option is passed on to the tokenizer and lexer, where it specifies
whether the parse should assume C is in effect.

The C<'strict'> pragma was introduced in Perl 5.22, and its
documentation says that it is experimental, and that there is no
commitment to backward compatibility. The same applies to the
parse produced when this option is asserted. Also, the usual caveat
applies: if C ends up being retracted, this option and
all related functionality will be also.

Given the nature of C, you should expect that if you
assert this option, regular expressions that previously parsed without
error might no longer do so. If an element ends up being declared an
error because this option is set, its C will
be the Perl version at which C started rejecting these
elements.

The default is false.

=item trace number

If greater than zero, this option causes trace output from the parse.
The author reserves the right to change or eliminate this without
notice.

=back

Passing optional input other than the above is not an error, but neither
is it supported.

=cut

{

    my $errstr;

    sub new {
	my ( $class, $content, %args ) = @_;
	ref $class and $class = ref $class;

	# We have to do this very early so the tokenizer can see it.
	defined $args{index_locations}
	    or $args{index_locations} = (
	    !! $args{location} || __instance( $content, 'PPI::Element' ) );

	$errstr = undef;

	# As of 0.068_01 this either fails or returns
	# PPIx::Regexp::Tokenizer
	my $tokenizer_class = __choose_tokenizer_class( $content, \%args );

	my $tokenizer = $tokenizer_class->new(
	    $content, %args ) or do {
	    $errstr = PPIx::Regexp::Tokenizer->errstr();
	    return;
	};

	my $lexer = PPIx::Regexp::Lexer->new( $tokenizer, %args );
	my @nodes = $lexer->lex();
	my $self = $class->SUPER::__new( @nodes );
	$self->{index_locations} = $args{index_locations};
	$self->{source} = $content;
	$self->{failures} = $lexer->failures();
	$self->{effective_modifiers} =
	    $tokenizer->__effective_modifiers();
	if ( $args{location} ) {
	    ARRAY_REF eq ref $args{location}
		or croak q;
	    foreach my $inx ( 0 .. 3 ) {
		$args{location}[$inx] =~ m/ [^0-9] /smx
		    and croak "Argument 'location' element $inx must be an unsigned integer";
	    }
	    $self->{location} = $args{location};
	}
	return $self;
    }

    sub errstr {
	return $errstr;
    }

}

=head2 new_from_cache

This static method wraps L in a caching mechanism. Only one object
will be generated for a given L, no matter
how many times this method is called. Calls after the first for a given
L simply return the same C
object.

When the C object is returned from cache, the values of
the optional arguments are ignored.

Calls to this method with the regular expression in a string rather than
a L will not be cached.

B This method is provided for code like
L which might instantiate the same object
multiple times. The cache will persist until L is called.

=head2 flush_cache

 $re->flush_cache();            # Remove $re from cache
 PPIx::Regexp->flush_cache();   # Empty the cache

This method flushes the cache used by L. If called as a
static method with no arguments, the entire cache is emptied. Otherwise
any objects specified are removed from the cache.

=cut

{

    my %cache;

    our $DISABLE_CACHE;		# Leave this undocumented, at least for
				# now.

    sub __cache_size {
	return scalar keys %cache;
    }

    sub new_from_cache {
	my ( $class, $content, %args ) = @_;

	__instance( $content, 'PPI::Element' )
	    or return $class->new( $content, %args );

	$DISABLE_CACHE and return $class->new( $content, %args );

	my $addr = refaddr( $content );
	exists $cache{$addr} and return $cache{$addr};

	my $self = $class->new( $content, %args )
	    or return;

	$cache{$addr} = $self;

	return $self;

    }

    sub flush_cache {
	my @args = @_;

	ref $args[0] or shift @args;

	if ( @args ) {
	    foreach my $obj ( @args ) {
		if ( __instance( $obj, __PACKAGE__ ) &&
		    __instance( ( my $parent = $obj->source() ),
			'PPI::Element' ) ) {
		    delete $cache{ refaddr( $parent ) };
		}
	    }
	} else {
	    %cache = ();
	}
	return;
    }

}

sub can_be_quantified { return; }

=head2 capture_names

 foreach my $name ( $re->capture_names() ) {
     print "Capture name '$name'\n";
 }

This convenience method returns the capture names found in the regular
expression.

This method is equivalent to

 $self->regular_expression()->capture_names();

except that if C<< $self->regular_expression() >> returns C
(meaning that something went terribly wrong with the parse) this method
will simply return.

=cut

sub capture_names {
    my ( $self ) = @_;
    my $re = $self->regular_expression() or return;
    return $re->capture_names();
}

=head2 delimiters

 print join("\t", PPIx::Regexp->new('s/foo/bar/')->delimiters());
 # prints '//      //'

When called in list context, this method returns either one or two
strings, depending on whether the parsed expression has a replacement
string. In the case of non-bracketed substitutions, the start delimiter
of the replacement string is considered to be the same as its finish
delimiter, as illustrated by the above example.

When called in scalar context, you get the delimiters of the regular
expression; that is, element 0 of the array that is returned in list
context.

Optionally, you can pass an index value and the corresponding delimiters
will be returned; index 0 represents the regular expression's
delimiters, and index 1 represents the replacement string's delimiters,
which may be undef. For example,

 print PPIx::Regexp->new('s{foo}')->delimiters(1);
 # prints '<>'

If the object was not initialized with a valid regexp of some sort, the
results of this method are undefined.

=cut

sub delimiters {
    my ( $self, $inx ) = @_;

    my @rslt;
    foreach my $method ( qw{ regular_expression replacement } ) {
	defined ( my $obj = $self->$method() ) or next;
	push @rslt, $obj->delimiters();
    }

    defined $inx and return $rslt[$inx];
    wantarray and return @rslt;
    defined wantarray and return $rslt[0];
    return;
}

=head2 errstr

This static method returns the error string from the most recent attempt
to instantiate a C. It will be C if the most recent
attempt succeeded.

=cut

# defined above, just after sub new.

sub explain {
    return;
}

=head2 extract_regexps

 my $doc = PPI::Document->new( $path );
 $doc->index_locations();
 my @res = PPIx::Regexp->extract_regexps( $doc )

This convenience (well, sort-of) static method takes as its argument a
L object and returns C
objects corresponding to all regular expressions found in it, in the
order in which they occur in the document. You will need to keep a
reference to the original L object if you
wish to be able to recover the original L
objects via the L
L method.

=cut

sub extract_regexps {
    my ( $class, $doc ) = @_;
    my @found = map { @{ $doc->find( $_ ) || [] } } qw{
	PPI::Token::QuoteLike::Regexp
	PPI::Token::Regexp::Match
	PPI::Token::Regexp::Substitute
    };
    return ( map { $class->new( $_ ) } map { $_->[0] }
	sort { $a->[1][0] <=> $b->[1][0] || $a->[1][1] <=> $b->[1][1] }
	map { [ $_, $_->location() ] }
	@found
    );
}

=head2 failures

 print "There were ", $re->failures(), " parse failures\n";

This method returns the number of parse failures. This is a count of the
number of unknown tokens plus the number of unterminated structures plus
the number of unmatched right brackets of any sort.

=cut

sub failures {
    my ( $self ) = @_;
    return $self->{failures};
}

=head2 max_capture_number

 print "Highest used capture number ",
     $re->max_capture_number(), "\n";

This convenience method returns the highest capture number used by the
regular expression. If there are no captures, the return will be 0.

This method is equivalent to

 $self->regular_expression()->max_capture_number();

except that if C<< $self->regular_expression() >> returns C
(meaning that something went terribly wrong with the parse) this method
will too.

=cut

sub max_capture_number {
    my ( $self ) = @_;
    my $re = $self->regular_expression() or return;
    return $re->max_capture_number();
}

=head2 modifier

 my $re = PPIx::Regexp->new( 's/(foo)/${1}bar/smx' );
 print $re->modifier()->content(), "\n";
 # prints 'smx'.

This method retrieves the modifier of the object. This comes from the
end of the initializing string or object and will be a
L.

B that this object represents the actual modifiers present on the
regexp, and does not take into account any that may have been applied by
default (i.e. via the C argument to C). For
something that takes account of default modifiers, see
L, below.

In the event of a parse failure, there may not be a modifier present, in
which case nothing is returned.

=cut

sub modifier {
    my ( $self ) = @_;
    return $self->_component( 'PPIx::Regexp::Token::Modifier' );
}

=head2 modifier_asserted

 my $re = PPIx::Regexp->new( '/ . /',
     default_modifiers => [ 'smx' ] );
 print $re->modifier_asserted( 'x' ) ? "yes\n" : "no\n";
 # prints 'yes'.

This method returns true if the given modifier is asserted for the
regexp, whether explicitly or by the modifiers passed in the
C argument.

Starting with version 0.036_01, if the argument is a
single-character modifier followed by an asterisk (intended as a wild
card character), the return is the number of times that modifier
appears. In this case an exception will be thrown if you specify a
multi-character modifier (e.g.  C<'ee*'>), or if you specify one of the
match semantics modifiers (e.g.  C<'a*'>).

=cut

sub modifier_asserted {
    my ( $self, $modifier ) = @_;
    return PPIx::Regexp::Token::Modifier::__asserts(
	$self->{effective_modifiers},
	$modifier,
    );
}

# This is a kluge for both determining whether the object asserts
# modifiers (hence the 'ductype') and determining whether the given
# modifier is actually asserted. The signature is the invocant and the
# modifier name, which must not be undef. The return is a Boolean.
*__ducktype_modifier_asserted = \&modifier_asserted;

# As of Perl 5.21.1 you can not leave off the type of a '?'-delimited
# regexp. Because this is not associated with any single child we
# compute it here.
sub perl_version_removed {
    my ( $self ) = @_;
    my $v = $self->SUPER::perl_version_removed();
    defined $v
	and $v <= 5.021001
	and return $v;
    defined( my $delim = $self->delimiters() )
	or return $v;
    '??' eq $delim
	and '' eq $self->type()->content()
	and return '5.021001';
    return $v;
}

=head2 regular_expression

 my $re = PPIx::Regexp->new( 's/(foo)/${1}bar/smx' );
 print $re->regular_expression()->content(), "\n";
 # prints '/(foo)/'.

This method returns that portion of the object which actually represents
a regular expression.

=cut

sub regular_expression {
    my ( $self ) = @_;
    return $self->_component( 'PPIx::Regexp::Structure::Regexp' );
}

=head2 replacement

 my $re = PPIx::Regexp->new( 's/(foo)/${1}bar/smx' );
 print $re->replacement()->content(), "\n";
 # prints '${1}bar/'.

This method returns that portion of the object which represents the
replacement string. This will be C unless the regular expression
actually has a replacement string. Delimiters will be included, but
there will be no beginning delimiter unless the regular expression was
bracketed.

=cut

sub replacement {
    my ( $self ) = @_;
    return $self->_component( 'PPIx::Regexp::Structure::Replacement' );
}

=head2 source

 my $source = $re->source();

This method returns the object or string that was used to instantiate
the object.

=cut

sub source {
    my ( $self ) = @_;
    return $self->{source};
}

=head2 type

 my $re = PPIx::Regexp->new( 's/(foo)/${1}bar/smx' );
 print $re->type()->content(), "\n";
 # prints 's'.

This method retrieves the type of the object. This comes from the
beginning of the initializing string or object, and will be a
L
whose C is one of 's',
'm', 'qr', or ''.

=cut

sub type {
    my ( $self ) = @_;
    return $self->_component( 'PPIx::Regexp::Token::Structure' );
}

sub _component {
    my ( $self, $class ) = @_;
    foreach my $elem ( $self->children() ) {
	$elem->isa( $class ) and return $elem;
    }
    return;
}

1;

__END__