expand results from the CPAN

expand

Apache-Config-Preproc

view release on metacpan or search on metacpan

lib/Apache/Config/Preproc.pm view on Meta::CPAN

    }
    if (@_) {
	croak "Too many import parameters";
    }
    $class->SUPER::import();
}

sub new {
    my $class = shift;
    my $file = shift;
    my $explist = Apache::Admin::Config::Tree::_get_arg(\@_, '-expand')
	|| [ qw(include) ];

    my $self = $class->SUPER::new($file, @_) or return;
    bless $self, $class;
    $self->{_filename} = $file;
    $self->{_options} = \@_;

    eval {
	$self->_preproc($explist);
    };

lib/Apache/Config/Preproc.pm view on Meta::CPAN

    $_->begin_section($section) foreach (@$modlist);
  OUTER:
    for (my $i = 0;
	 defined(my $d = do {
	     local $SIG{__WARN__} = sub {
		 my $msg = shift;
		 warn "$msg" unless $msg =~ /uninitialized/;
	     };
	     $section->select(-which => $i) }); ) {
	foreach my $mod (@$modlist) {
	    if ($mod->expand($d, \my @repl)) {
		my $prev = $d;
		foreach my $r (@repl) {
		    $prev = $section->add($r, -after => $prev);
		}
		$d->unlink;
		next OUTER;
	    }
	    if ($d->type eq 'section') {
		$self->_preproc_section_default($d, $modlist);
	    }

lib/Apache/Config/Preproc.pm view on Meta::CPAN

# the following implementation is used:
sub _preproc_section_optimized {
    my ($self, $section, $modlist) = @_;

    return unless @$modlist;

    $_->begin_section($section) foreach (@$modlist);
  OUTER:
    for (my $i = 0; defined(my $d = $section->get_nth($i)); ) {
	foreach my $mod (@$modlist) {
	    if ($mod->expand($d, \my @repl)) {
		$section->replace_inplace($i, @repl);
		next OUTER;
	    }
	    if ($d->type eq 'section') {
		$self->_preproc_section_optimized($d, $modlist);
	    }
	}
	$i++;
    }
    $_->end_section($section) foreach (@$modlist);

lib/Apache/Config/Preproc.pm view on Meta::CPAN


=head1 NAME

Apache::Config::Preproc - Preprocess Apache configuration files

=head1 SYNOPSIS

    use Apache::Config::Preproc;
    
    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
             -expand => [ qw(include compact macro ifmodule ifdefine) ] 
             or die $Apache::Admin::Config::ERROR;

=head1 DESCRIPTION

B<Apache::Config::Preproc> reads and parses Apache configuration
file, expanding the syntactic constructs selected by the B<-expand> option.
In the simplest case, the argument to that option is a reference to the
list of names. Each name in the list identifies a module responsible for
processing specific Apache configuration keywords. For convenience, most
modules are named after the keyword they process, so that, e.g. B<include> is
responsible for inclusion of the files listed with B<Include> and
B<IncludeOptional> statements. The list of built-in module names follows:    

=over 4

=item B<compact>

lib/Apache/Config/Preproc.pm view on Meta::CPAN


Expands the B<E<lt>MacroE<gt>> statements.    

=back

See the section B<MODULES> for a detailed description of these modules.

More expansions can be easily implemented by supplying a corresponding
expansion module (see the section B<MODULE INTERNALS> below).

If the B<-expand> argument is not supplied, the following default is
used:

    [ 'include' ]
    
The rest of methods is inherited from B<Apache::Admin::Config>.

=head1 IMPORT

The package provides two implementations of the main preprocessing
method.  The default implementation uses only the documented methods

lib/Apache/Config/Preproc.pm view on Meta::CPAN


    use Apache::Config::Preproc qw(:optimized);

See the source code for details.

=head1 CONSTRUCTOR

=head2 new

    $obj = new Apache::Config::Preproc $file,
          [-expand => $modlist],
          [-indent => $integer], ['-create'], ['-no-comment-grouping'],
          ['-no-blank-grouping']

Reads the Apache configuration file from I<$file> and preprocesses it.
The I<$file> argument can be either the file name or file handle.

The keyword arguments are:

=over 4

=item B<-expand> =E<gt> I<$arrayref>

Define what expansions are to be performed. B<$arrayref> is a reference to
array of module names with optional arguments. To supply arguments,
use either a list reference where the first element is the module
name and rest of elements are arguments, or a hash reference with the name
of the module as key and a reference to the list of arguments as its value.
Consider, for example:

    -expand => [ 'include', { ifmodule => { probe => 1 } } ]

    -expand => [ 'include', [ 'ifmodule', { probe => 1 } ] ]

Both constructs load the B<include> module with no specific arguments,
and the B<ifmodule> module with the arguments B<probe =E<gt> 1>.
    
See the B<MODULES> section for a discussion of built-in modules and allowed
arguments.    

A missing B<-expand> argument is equivalent to

    -expand => [ 'include' ]
    
=back

Rest of arguments is the same as for the B<Apache::Admin::Config> constructor:

=over 4    
    
=item B<-indent> =E<gt> I<$n>

Enables reindentation of the configuration content. The B<$n> argument

lib/Apache/Config/Preproc.pm view on Meta::CPAN

Returns the name of the configuration file.

=head2 options

Returns the list of options passed to the constructor when creating
the object.    
    
=head1 MODULES

The preprocessing phases to be performed on the parsed configuration text are
defined by the B<-expand> argument. Internally, each name in its argument
list causes loading of a Perl module responsible for this particular phase.
Arguments to the constructor can be supplied using any of the following
constructs:

       { NAME => [ ARG, ...] }

or

       [ NAME, ARG, ... ]

lib/Apache/Config/Preproc.pm view on Meta::CPAN

    probe => 1

is a shorthand for

    probe => [qw(/usr/sbin/httpd /usr/sbin/apache2)]

=back

=head2 ifdefine

Eliminates the B<Define> and B<UnDefine> statements and expands the
B<E<lt>IfDefineE<gt>> statements in the Apache configuration parse
tree. Optional arguments to the constructor are treated as the names
of symbols to define (similar to the B<httpd> B<-D> options). Example:   

    -expand => [ { ifdefine => [ qw(SSL FOREGROUND) ] } ]

=head2 locus

Attaches to each node in the parse tree a L<Text::Locus> object
which describes the location of the corresponding statement in the source
file.  The location for each node can be accessed via the B<locus> method.
E.g. the following prints location and type of each statement:

    $x = new Apache::Config::Preproc '/etc/httpd.conf',
                                     -expand => [ qw(locus) ];

    foreach ($x->select) {
        print $_->locus
    }
    
See L<Text::Locus> for a detailed discussion of the locus object and its
methods.

=head2 macro

Processes B<Macro> and B<Use> statements (see B<mod_macro>).  B<Macro>
statements are removed. Each B<Use> statement is replaced by the expansion
of the macro named in its argument.

The constructor accepts the following arguments:
    
=over 4

=item B<keep =E<gt>> I<$listref>

List of macro names to exclude from expanding. Each B<E<lt>MacroE<gt>> and
B<Use> statement with a name from I<$listref> as its first argument will be
retained in the parse tree.

As a syntactic sugar, I<$listref> can also be a scalar value. This is
convenient when a single macro name is to be retained.    

=back
    
=head1 MODULE INTERNALS 

Each keyword I<phase> listed in the B<-expand> array causes loading of the
package B<Apache::Config::Preproc::I<phase>>.  This package must inherit
from B<Apache::Config::Preproc::Expand> and overload at least the
B<expand> method.  See the description of B<Apache::Config::Preproc::Expand>
for a detailed description.

=head1 EXAMPLE

    my $obj = new Apache::Config::Preproc('/etc/httpd/httpd.conf',
                   -expand => [qw(compact include ifmodule macro)],
                   -indent => 4) or die $Apache::Admin::Config::ERROR;
    print $obj->dump_raw

This snippet loads the Apache configuration from file
F</etc/httpd/httpd.conf>, performs all the built-in expansions, and prints
the result on standard output, using 4 character indent for each additional
level of nesting.    

=head1 SEE ALSO

lib/Apache/Config/Preproc/Expand.pm view on Meta::CPAN

Invoked when all preprocessor expansions are finished for a section.  The
section (an instance of B<Apache::Admin::Config::Tree> or a derived class) is
passed as the argument.

Default implementation is a no-op.

=cut

sub end_section {}

=head2 expand

    $result = $obj->expand($node, \@items);

Expands the configuration tree node B<$node>, places the resulting
nodes to B<@items> and returns true.  Returns false if no expansion
was done on the node.

=cut

sub expand {}

1;

lib/Apache/Config/Preproc/compact.pm view on Meta::CPAN

package Apache::Config::Preproc::compact;
use parent 'Apache::Config::Preproc::Expand';
use strict;
use warnings;
use Carp;

our $VERSION = '1.03';

sub expand {
    my ($self, $d) = @_;
    $d->type eq 'blank' || $d->type eq 'comment';
}

1;

__END__

=head1 NAME    

Apache::Config::Preproc::compact - remove empty lines and comments

=head1 SYNOPSIS

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [ qw(compact) ]; 

=head1 DESCRIPTION

Removes empty and comment lines from the Apache configuration parse
tree.

=head1 SEE ALSO

L<Apache::Config::Preproc>

lib/Apache/Config/Preproc/ifdefine.pm view on Meta::CPAN

sub define {
    my ($self,$id) = @_;
    $self->{D}{$id} = 1;
}

sub undefine {
    my ($self,$id) = @_;
    delete $self->{D}{$id};
}

sub expand {
    my ($self, $d, $repl) = @_;
    if ($d->type eq 'section') {
	if (lc($d->name) eq 'ifdefine') {
	    my $id = $d->value;
	    my $negate = $id =~ s/^!//;
	    my $res = $self->is_defined($id, $d);
	    $res = !$res if $negate;
	    if ($res) {
		push @$repl, $d->select;
	    }

lib/Apache/Config/Preproc/ifdefine.pm view on Meta::CPAN

	}
    }
    return 0;
}

1;
__END__

=head1 NAME    

Apache::Config::Preproc::ifdefine - expand IfDefine sections

=head1 SYNOPSIS

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
               -expand => [ qw(ifdefine) ];

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
               -expand => [
                   { ifdefine => [qw(SYM1 SYM2)] }
               ];

=head1 DESCRIPTION

Eliminates the B<Define> and B<UnDefine> statements and expands the
B<E<lt>IfDefineE<gt>> statements in the Apache configuration parse
tree. Optional arguments to the constructor are treated as the names
of symbols to define (similar to the B<httpd> B<-D> options).    
    
=head1 SEE ALSO

L<Apache::Config::Preproc>

=cut

lib/Apache/Config/Preproc/ifmodule.pm view on Meta::CPAN


sub preloaded {
    my $self = shift;
    my $id = shift;
    if (my $v = shift) {
	$self->{preloaded}{$id} = $v;
    }
    return $self->{preloaded}{$id};
}

sub expand {
    my ($self, $d, $repl) = @_;
    if ($d->type eq 'section' && lc($d->name) eq 'ifmodule') {
	my $id = $d->value;
	my $negate = $id =~ s/^!//;
	my $res = $self->module_loaded($id);
	if ($negate) {
	    $res = !$res;
	}
	if ($res) {
	    push @$repl, $d->select;

lib/Apache/Config/Preproc/ifmodule.pm view on Meta::CPAN

    }
    close $nullin;
    close $nullout;
}

1;
__END__

=head1 NAME    

Apache::Config::Preproc::ifmodule - expand IfModule statements

=head1 SYNOPSIS

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
               -expand => [ qw(ifmodule) ];

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
               -expand => [
                   { ifmodule => { probe => [ '/usr/sbin/httpd' ] } }
               ]; 

=head1 DESCRIPTION

Expands the B<E<lt>IfModuleE<gt>> statements in the Apache configuration parse
tree. If the statement's argument evaluates to true, it is replaced by the
statements inside it. Otherwise, it is removed. Nested statements are allowed.
The B<LoadModule> statements are examined in order to evaluate the argument.

lib/Apache/Config/Preproc/include.pm view on Meta::CPAN

sub context_push {
    my ($self,$file,$dev,$ino) = @_;
    push @{$self->{context}}, { file => $file, dev => $dev, ino => $ino };
}

sub context_pop {
    my $self = shift;
    pop @{$self->{context}};
}

sub expand {
    my ($self, $d, $repl) = @_;

    if ($d->type eq 'directive') {
	if (lc($d->name) eq 'serverroot') {
	    $self->server_root($d->value);
	} elsif ($d->name =~ /^include(optional)?$/i) {
	    my $optional = $1;

	    my $pat = $self->conf->dequote($d->value);
	    unless (File::Spec->file_name_is_absolute($pat)) {

lib/Apache/Config/Preproc/include.pm view on Meta::CPAN

    my $path = abs_path($file);
    return grep { $_->{file} eq $path } @{$self->{context}}; 
}

1;

__END__

=head1 NAME    

Apache::Config::Preproc::include - expand Include statements

=head1 SYNOPSIS

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [ qw(include) ];

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [
                    { include => [ server_root => $dir ] }
                ];

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [
                    { include => [ probe => [ '/usr/sbin/httpd' ] ] }
                ];

=head1 DESCRIPTION

Processes B<Include> and B<IncludeOptional> statements and replaces them
with the contents of the files supplied in their arguments. If the argument
is not an absolute file name, it is searched in the server root directory.

Keyword arguments:

lib/Apache/Config/Preproc/locus.pm view on Meta::CPAN

    $self->{line} = 0;
}

sub context_pop {
    my $self = shift;
    if (my $ctx = pop @{$self->{context}}) {
	($self->{filename}, $self->{line}) = @$ctx;
    }
}

sub expand {
    my ($self, $d, $repl) = @_;

    # Prevent recursion
    return 0 if $d->can('locus');

    # Handle context switches due to include statements.
    if ($d->type eq 'directive') {
	if ($d->name eq '$PUSH$') {
	    if ($d->value =~ /^\"(.+)\"/) {
		$self->context_push($1);

lib/Apache/Config/Preproc/locus.pm view on Meta::CPAN

1;
__END__

=head1 NAME    

Apache::Config::Preproc::locus - attach file location to each parse node

=head1 SYNOPSIS

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [ qw(locus) ];

    foreach ($x->select) {
        print $_->locus
    }

=head1 DESCRIPTION

B<Locus> attaches to each node in the parse tree a B<Text::Locus> object
which describes the location of the corresponding statement in the source
file.  The location of a node can be accessed via the B<locus> method

lib/Apache/Config/Preproc/macro.pm view on Meta::CPAN

    return $self->{macro}{$name};
}

sub install_macro {
    my ($self, $defn) = @_;
    return 0 if $self->{keep}{$defn->name};
    $self->{macro}{$defn->name} = $defn;
    return 1;
}

sub expand {
    my ($self, $d, $repl) = @_;
    if ($d->type eq 'section' && lc($d->name) eq 'macro') {
	return $self->install_macro(Apache::Config::Preproc::macro::defn->new($d));
    } 
    if ($d->type eq 'directive' && lc($d->name) eq 'use') {
	my ($name,@args) = parse_line(qr/\s+/, 0, $d->value);
	if (my $defn = $self->macro($name)) {
	    push @$repl, $defn->expand(@args);
	    return 1;
	}
    }
    return 0;
}

package Apache::Config::Preproc::macro::defn;
use strict;
use warnings;
use Text::ParseWords;

lib/Apache/Config/Preproc/macro.pm view on Meta::CPAN

	name => $name,
	params => [ @params ],
	code => [$d->select]
    }, $class;
}

sub name { shift->{name} }
sub params { @{shift->{params}} }
sub code { @{shift->{code}} }

sub expand {
    my ($self, @args) = @_;
    
    my @rxlist = map {
	my $r = shift @args // '';
	my $q = quotemeta($_);
	[ qr($q), $r ]
    } $self->params;
    map { $self->_node_expand($_->clone, @rxlist) } $self->code;
}

sub _node_expand {
    my ($self, $d, @rxlist) = @_;

    if ($d->type eq 'directive') {
	$d->value($self->_repl($d->value, @rxlist));
    } elsif ($d->type eq 'section') {
	$d->value($self->_repl($d->value, @rxlist));
	foreach my $st ($d->select) {
	    $self->_node_expand($st, @rxlist);
	}
    }
    return $d;
}

sub _repl {
    my ($self, $v, @rxlist) = @_;
    foreach my $rx (@rxlist) {
	$v =~ s{$rx->[0]}{$rx->[1]}g;
    }
    return $v
}

1;

__END__

=head1 NAME    

Apache::Config::Preproc::macro - expand macro statements

=head1 SYNOPSIS

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [ qw(macro) ];

    $x = new Apache::Config::Preproc '/path/to/httpd.conf',
                -expand => [ { macro => [ keep => $listref ] } ];

=head1 DESCRIPTION

Processes B<Macro> and B<Use> statements (see B<mod_macro>) in the
Apache configuration parse tree.

B<Macro> statements are removed. Each B<Use> statement is replaced by the
expansion of the macro named in its argument.

The constructor accepts the following arguments:

=over 4

=item B<keep =E<gt>> I<$listref>

List of macro names to exclude from expanding. Each B<E<lt>MacroE<gt>> and
B<Use> statement with a name from I<$listref> as its first argument will be
retained in the parse tree.

As a syntactic sugar, I<$listref> can also be a scalar value. This is
convenient when a single macro name is to be retained.    

=back
    
=head1 SEE ALSO

t/00compact.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => [qw(compact)];
ok($obj->dump_raw, $obj->dump_expect);
__DATA__
!>httpd.conf
# Main file
ServerName localhost

  ServerRoot "$server_root"
# Comment 1
# Comment 2
!=

t/01include00.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => [qw(include)];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
# Main file
ServerName localhost
ServerRoot "$server_root"
Include vhost.conf
PidFile logs/httpd.pid
!>vhost.conf

t/01include01.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
# Test include by globbing pattern
my $obj = new TestPreproc -expand => [qw(include)];
ok($obj->dump_raw, $obj->dump_expect);
__DATA__
!>httpd.conf
ServerType standalone
ServerRoot "$server_root"
Include conf.d/*.conf
PidFile logs/httpd.pid
!>conf.d/a.conf
Timeout 300
!>conf.d/b.conf

t/01include02.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
# Test nested includes
my $obj = new TestPreproc -expand => [qw(include)];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
# Main configuration
ServerType standalone
ServerRoot "$server_root"
Include "level1.conf"
PidFile logs/httpd.pid
!>level1.conf

t/01include03.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 2;

use TestPreproc;
# Test recursive inclusion handling
ok(!new TestPreproc '-expect_fail', -expand => [qw(include)]);
ok($Apache::Admin::Config::ERROR, qr/level1.conf already included/);
__DATA__
!>httpd.conf
ServerType standalone
ServerRoot "$server_root"
Include level1.conf
!>level1.conf
Include level2.conf
!>level2.conf
Include level3.conf

t/01include04.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
# Test whether a file can be included non-recursively multiple times
my $obj = new TestPreproc -expand => [qw(include)];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
ServerType standalone
ServerRoot "$server_root"
<VirtualHost *:80>
  ServerName foo.bar.example.com
  Include req.conf
</VirtualHost>

t/03ifmodule00.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => [qw(ifmodule)];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
LoadModule mpm_prefork_module lib/httpd/modules/mod_mpm_prefork.so
LoadModule unixd_module lib/httpd/modules/mod_unixd.so

<IfModule !mpm_netware_module>
    PidFile "/var/run/httpd.pid"
</IfModule>

t/03ifmodule01.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 4;

use TestPreproc;

my $obj = new TestPreproc -expand => [qw(ifmodule)];
ok($obj->dump_raw, $obj->dump_expect);

$obj = new TestPreproc -expand => [qw(ifmodule)];
ok($obj->dump_raw, $obj->dump_expect);

$obj = new TestPreproc -expand => [qw(ifmodule)];
ok($obj->dump_raw, $obj->dump_expect);

$obj = new TestPreproc -expand => [qw(ifmodule)];
ok($obj->dump_raw, $obj->dump_expect);
__DATA__
!>httpd.conf
LoadModule mpm_prefork_module lib/httpd/modules/mod_mpm_prefork.so
<IfModule log_config_module>
LogFormat "%a" combined
<IfModule logio_module>
LogFormat "%a %I %O" combinedio
</IfModule>
</IfModule>

t/04macro00.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => ['macro'];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
ServerName localhost
<Macro vhost $name $port $dir>
  <VirtualHost *:$port>
    # Comment
    ServerName $name
    DocumentRoot $dir

t/04macro01.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => ['macro'];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
ServerName localhost
<Macro SSL $domain>
SSLEngine on
SSLCertificateFile /etc/ssl/acme/$domain.pem
</Macro>
<Macro vhost $name $port $dir>

t/04macro02.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => [ { macro => [ keep => 'SSL' ] } ];
ok($obj->dump_raw, $obj->dump_expect);
__DATA__
!>httpd.conf
ServerName localhost
<Macro SSL $domain>
SSLEngine on
SSLCertificateFile /etc/ssl/acme/$domain.pem
</Macro>
<Macro vhost $name $port $dir>
<VirtualHost *:$port>

t/05ifdefine00.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 3;

use TestPreproc;

my $obj = new TestPreproc -expand => ['ifdefine'];
ok($obj->dump_raw, $obj->dump_expect);

$obj = new TestPreproc -expand => [ { ifdefine => [qw(VAR)] } ];
ok($obj->dump_raw, $obj->dump_expect);

$obj = new TestPreproc -expand => ['ifdefine'];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
ServerAdmin foo
<IfDefine VAR>
  ServerName localhost
</IfDefine>
!=
ServerAdmin foo

t/05ifdefine01.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => ['ifdefine'];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
Define FOO
ServerName localhost
<IfDefine FOO>
   ServerAlias remote
</IfDefine>
UnDefine FOO

t/05ifdefine02.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => ['ifdefine'];
ok($obj->dump_raw, $obj->dump_expect);

__DATA__
!>httpd.conf
<VirtualHost bar>
   ServerName localhost
   ServerAdmin root
   Define FOO
</VirtualHost>  
<IfDefine FOO>

t/06locus00.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
my $obj = new TestPreproc -expand => [qw(locus)];
ok($obj->dump_reformat_synclines, $obj->dump_expect)

__DATA__
!>httpd.conf
# Start of file

# Comment 1
# Comment 2
# Comment 3

t/06locus01.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
my $obj = new TestPreproc -expand => [qw(locus)],
                          '-no-comment-grouping' => 1,
                          '-no-blank-grouping' => 1;
ok($obj->dump_reformat_synclines, $obj->dump_expect)

__DATA__
!>httpd.conf
# Start of file

# Comment 1
# Comment 2

t/06locus02.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
my $obj = new TestPreproc -expand => [qw(locus)];
ok($obj->dump_reformat_synclines eq $obj->dump_expect);

__DATA__
!>httpd.conf
# Start of file
ServerName localhost

ServerAdmin foo@example.net

<VirtualHost *:80>

t/06locus03.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
my $obj = new TestPreproc -expand => [qw(locus include)];
ok($obj->dump_reformat_synclines,$obj->dump_expect);

__DATA__
!>httpd.conf
# Start of file
ServerRoot "$server_root"
ServerAdmin foo@example.net
Include vhost1.conf
Include vhost2.conf
PidFile logs/httpd.pid

t/06locus04.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;
my $obj = new TestPreproc -expand => [qw(locus macro)];
ok($obj->dump_reformat_synclines,$obj->dump_expect);

__DATA__
!>httpd.conf
# Start of file
ServerRoot "$server_root"
<Macro X $arg>
    Foo $arg
</Macro>
EndStatement true

t/06locus05.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 3;

use TestPreproc;

my $obj = new TestPreproc -expand => ['locus', 'ifdefine'];
ok($obj->dump_reformat_synclines, $obj->dump_expect);

$obj = new TestPreproc -expand => [ 'locus', { ifdefine => [qw(VAR)] } ];
ok($obj->dump_reformat_synclines, $obj->dump_expect);

$obj = new TestPreproc -expand => ['locus', 'ifdefine'];
ok($obj->dump_reformat_synclines, $obj->dump_expect);

__DATA__
!>httpd.conf
ServerAdmin foo
<IfDefine VAR>
  ServerName localhost
</IfDefine>
!=
# $server_root/httpd.conf:1

t/06locus06.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => [qw(locus ifmodule)];
ok($obj->dump_reformat_synclines, $obj->dump_expect);

__DATA__
!>httpd.conf
LoadModule mpm_prefork_module lib/httpd/modules/mod_mpm_prefork.so
LoadModule unixd_module lib/httpd/modules/mod_unixd.so

<IfModule !mpm_netware_module>
    PidFile "/var/run/httpd.pid"
</IfModule>

t/99all00.t view on Meta::CPAN

# -*- perl -*-
use lib qw(t lib);
use strict;
use Test;
plan test => 1;

use TestPreproc;

my $obj = new TestPreproc -expand => [qw(compact include ifmodule macro ifdefine)];
ok($obj->dump_raw, $obj->dump_expect);
__DATA__
!>httpd.conf
# Main file
ServerName localhost
ServerRoot "$server_root"

Include conf.d/*.conf

Include mpm.conf

( run in 1.064 second using v1.01-cache-2.11-cpan-5b529ec07f3 )