use Test::Without::Modules qw( HTML::Template );
use Test::Without::Modules qr/^POE::/;

##</code><code>##

BEGIN { @SAVED_INC = @INC; };
sub import {
  @INC = sub {
    # return undef if it's a blocked module
    # Look if the module is in @SAVED_INC
    # Return a filehandle to it
  };
};

##</code><code>##

BEGIN { @SAVED_INC = @INC; };
sub import {
  @INC = sub {
    # return undef if it's a blocked module
  };
};

##</code><code>##

sub import {
  $INC{$module} = 1;
  *{$module."::import"} = sub {
    die 'ugh';
  };
};

##</code><code>##

  eval { require Optional::Module };
  if ($@) {
    # module is not available
  };

##</code><code>##

sub import {
  unshift @INC, sub {
    # return dummy module filehandle if it's a blocked module
  };
};

##</code><code>##

use vars qw( %forbidden );
sub import {
  my ($self,@forbidden_modules) = @_;
  scrub( $module )
    for @forbidden_modules;
  unshift @INC, sub {
    my (undef,$filename,undef) = @_;
    if (exists $forbidden{$filename}) {
      # return faked, failing module
    };
  };
};

##</code><code>##

package Test::Without::Module;
use strict;
use File::Temp;
use Carp qw( croak );

use vars qw( %forbidden $VERSION );
$VERSION = 0.01;

sub import {
  my ($self,@forbidden_modules) = @_;

  $forbidden{$_} = $_
    for @forbidden_modules;

  # Scrub %INC, so that loaded modules disappear
  my ($module);
  for $module (@forbidden_modules) {
    scrub( $module );
  };

  # Move our handler to the front of the list
  @INC = grep { $_ ne \&fake_module } @INC;
  unshift @INC, \&fake_module;
};

sub fake_module {
    my ($self,$module_file,$member_only) = @_;
    warn $@ if $@;

    my $modulename = file2module($module_file);

    # Deliver a faked, nonworking module
    if (grep { $modulename =~ $_ } keys %forbidden) {

      my $fh = File::Temp::tmpfile();
      print $fh <<MODULE;
package $modulename;

=head1 NAME

$modulename

=head1 SYNOPSIS

!!! THIS IS A FAKED VERSION OF $modulename !!!
!!! IT WAS CREATED BY Test::Without::Module          !!!
!!! IT SHOULD NEVER END UP IN YOUR lib/ OR site/lib/ !!!

=cut

sub import { undef };
0;
MODULE
      seek $fh, 0,0;
      return $fh;
    };
};

sub unimport {
  my ($self,@list) = @_;
  my $module;
  for $module (@list) {
    if (exists $forbidden{$module}) {
      delete $forbidden{$module};
      scrub( $module );
    } else {
      croak "Can't allow non-forbidden module $module";
    };
  };
};

sub file2module {
  my ($mod) = @_;
  $mod =~ s!/!::!g;
  $mod =~ s!\.pm$!!;
  $mod;
};

sub scrub {
  my ($module) = @_;
  my $key;
  for $key (keys %INC) {
    delete $INC{$key}
      if (file2module($key) =~ $module);
  };
};

1;
__END__

=head1 NAME

Test::Without::Module - Test fallback behaviour in absence of modules

=head1 SYNOPSIS

=for example begin
  use Test::Without::Module qw( File::Temp );

  # Now, loading of File::Temp fails :
  eval { require File::Temp; };
  warn $@ if $@;

  # Now it works again
  eval q{ no Test::Without::Module qw( File::Temp ) };
  eval { require File::Temp; };
  print "Found File::Temp" unless $@;

=for example end

=head1 DESCRIPTION

This module allows you to deliberately hide modules from a program
even though they are installed. This is mostly useful for testing modules
that have a fallback when a certain dependency module is not installed.

=head2 EXPORT

None. All magic is done via C<use Test::Without::Module> and
C<no Test::Without::Module>.

=begin testing
  no warnings 'once';

  eval 'use Test::Without::Module qw( File::Temp )';
  eval 'no Test::Without::Module qw( File::Temp )';

  is_deeply( [keys %Test::Without::Module::forbidden],[],"Module list" );
  eval { require File::Temp; };
  is( $@, '', "unimport" );

=end testing

=head1 BUGS

=over 4

=item * There is no lexicalic scoping (yet)

=back

=head1 AUTHOR

Max Maischein, E<lt>corion@cpan.orgE<gt>

=head1 SEE ALSO

L<Acme::Intraweb>, L<PAR>, L<perlfunc>

=cut

##</code><code>##

perl -MHTTP::Daemon -MHTTP::Response -MLWP::Simple -e ' ;    # The  
$d = new HTTP::Daemon and fork and getprint $d->url and exit;#spider
($c = $d->accept())->get_request(); $c->send_response( new   #in the
HTTP::Response(200,$_,$_,qq(Just another Perl hacker\n))); ' #  web