view release on metacpan or  search on metacpan

lib/Apache/JAF.pm  view on Meta::CPAN

  #  0: critical errors only
  #  1: request processing line
  #  2: client request
  #  3: response headers
  #  4: template variables
  #  9: loading additional handlers
  # 10: processed template
  $self->{debug_level} = $self->{r}->dir_config('Apache_JAF_Debug') || 0;

  # Default response status and content-type
  $self->{status} = NOT_FOUND;
  $self->{type} = 'text/html';

  # Default template and includes extensions
  $self->{template_ext} = '.html';
  $self->{include_ext} = '.inc';
  $self->{default_include} = 'default';

  # pre- and post-process templates (without extensions)
  $self->{header} = 'header';
  $self->{footer} = 'footer';
  $self->{pre_chomp} = $self->{post_chomp} = $self->{trim} = 1;

  # Templates folder
  $self->{templates} = $self->{r}->dir_config('Apache_JAF_Templates');
  # Modules folder
  $self->{modules} = $self->{r}->dir_config('Apache_JAF_Modules');

  # Compiled templates folder  
  $self->{compile_dir} = $self->{r}->dir_config('Apache_JAF_Compiled') || '/tmp';

  # This method must be implemented in derived class and must
  # provide $self->{handler} property
  $self->{handler} = $self->setup_handler();
  return undef unless $self->{handler};

  # Log real and uri without prefix
  $self->warn(1, "Starting $ref for " . $self->{r}->uri);
  $self->warn(1, "URI: /" . join '/', @{$self->{uri}});
  $self->warn(2, 'Request: ' . $self->{r}->as_string());

  # Load handlers if $HANDLERS_LOADED flag is unset or 
  # we are in debug mode ($self->{debug_level} > 0)
  # reload modified templates also
  my $package = ref $self;
  { no strict 'refs';
    $self->load_handlers($package, $self->{modules}) if $self->{debug_level} || !${ "${package}::HANDLERS_LOADED" };
    $self->load_templates($package, $self->{templates}, 1) if $self->{debug_level} && ${ "${package}::SELF_PROVIDER" };
  }

  # {page} key in result hash equals to current handler
  $self->{res}{page} = $self->{handler};

  return $self
}

# Load handlers and temlates during compile-time...
################################################################################
sub import {
  my ($package, %args) = @_;
  $package = (caller())[0];
  load_handlers(undef, $package, $args{handlers}) if $args{handlers};
  load_templates(undef, $package, $args{templates}) if $args{templates};
}

# Load handlers
################################################################################
our (%HANDLERS, $PACKAGE);

sub _process_as_handler {
  return unless /\.pm$/;
  my $text = undef;
  if (-f && -r) {
    open IN, $_;
    $text = do { local $/; <IN> };
    close IN;
    $HANDLERS{ $_ }{TEXT} = $text;
  }
}

sub load_handlers {
  my ($self, $package, $dir) = @_;
  $dir ||= $self->{modules} if $self;

  if ($dir eq 'auto') {
    $dir = $INC{ do { (my $dummy = $package) =~ s/::/\//g; "$dummy.pm"; } };
    $dir =~ s/\.pm$/\/pages\//;
    undef $dir unless -d $dir;
  } else {
    $dir .= '/' if $dir !~ /\/$/;
  }  

  if (defined $dir && -d $dir) {
    local %HANDLERS = ();
    File::Find::find({ wanted => \&_process_as_handler, no_chdir => 1 }, $dir);

    local $PACKAGE = qq{package $package; use strict;\n};
    my $line = 2;
    foreach my $file (keys %HANDLERS) {
      my $lines = $HANDLERS{ $file }{TEXT} =~ s/(\n)/$1/sg;
      $HANDLERS{ $file }{START} = $line;
      $HANDLERS{ $file }{END} = $line += $lines + 1;
      $PACKAGE .= $HANDLERS{ $file }{TEXT} . "\n";
    }
    $PACKAGE .= qq{\nour \$HANDLERS_LOADED=1;\n};

    $self && $self->warn(9, "Loading handlers for $package:\n $PACKAGE");
    eval $PACKAGE;

    if ($@) {
      (my $error = $@) =~ s/\(eval\s+\d+\)(\s+line\s+)(\d+)/
      do {
        my $replace = q{(can't find where...)};
        foreach my $file (keys %HANDLERS) {
          if ($HANDLERS{ $file }{START} <= $2 && $2 < $HANDLERS{ $file }{END}) {
            $replace = "($file)$1" . ($2 - $HANDLERS{ $file }{START} + 1);
            last;
          }
        }
        $replace;
      }