File Coverage

blib/lib/NNML/Config.pm

Criterion	Covered	Total	%
statement	6	79	7.5
branch	0	30	0.0
condition	0	9	0.0
subroutine	2	11	18.1
pod	0	8	0.0
total	8	137	5.8

#                              -*- Mode: Perl -*-
# Config.pm --
# ITIID           : $ITI$ $Header $__Header$
# Author          : Ulrich Pfeifer
# Created On      : Sat Sep 28 13:53:36 1996
# Last Modified By: Ulrich Pfeifer
# Last Modified On: Mon Sep 30 08:55:23 1996
# Language        : CPerl
# Update Count    : 11
# Status          : Unknown, Use with caution!
#
# (C) Copyright 1996, Universität Dortmund, all rights reserved.
#

package NNML::Config;

use strict;
use vars qw($VERSION @ISA @EXPORT_OK $Config);

require Exporter;

@ISA = qw(Exporter);

@EXPORT_OK = qw(
                $Config
               );

$VERSION = '0.01';


$Config = bless {
  'active'        => q[~/active],
  'base'          => q[~/Mail],
  'local_passwd'  => q[],
  'local_user'    => q[~],
  'mirror_host'   => q[],
  'mirror_port'   => q[119],
  'passwd'        => q[~/passwd],
  'port'          => q[119],
  'remote_passwd' => q[],
  'remote_user'   => q[~],
}, 'NNML::Config';

sub local_user {
  my $self = shift;
  my $user;

  if (defined $user) {
    $self->{local_user} = $user;
    delete $self->{_local_user};
  }
  return $self->{_local_user} if exists $self->{_local_user};
  if ($self->{local_user} eq '~') {
    my $user = $ENV{'USER'} || $ENV{'LOGNAME'} || getpwuid($<);
    $self->{_local_user} = $user;
  } else {
    $self->{_local_user} = $self->{local_user};
  }
  $self->{_local_user};
}

sub remote_user {
  my $self = shift;
  my $user;

  if (defined $user) {
    $self->{remote_user} = $user;
    delete $self->{_remote_user};
  }
  return $self->{_remote_user} if exists $self->{_remote_user};
  if ($self->{remote_user} eq '~') {
    my $user = $ENV{'USER'} || $ENV{'LOGNAME'} || getpwuid($<);
    $self->{_remote_user} = $user;
  } else {
    $self->{_remote_user} = $self->{remote_user};
  }
  $self->{_remote_user};
}

sub home {
  my $self = shift;

  return $self->{_home} if exists $self->{_home};
  my $user = $ENV{'USER'} || $ENV{'LOGNAME'} || getpwuid($<);
  my $home = (getpwnam($user))[7];
  $self->{_home} = $home;
}

sub base {
  my $self = shift;
  my $base = shift;

  if (defined $base) {
    $self->{base} = $base;
    delete $self->{_base};
    delete $self->{_active};
    delete $self->{_passwd};
  }
  return $self->{_base} if exists $self->{_base};
  $self->{_base} = $self->{base};
  $self->{_base} =~ s/^~/$self->home/e;
  $self->{_base};
}

sub spool {
  my $self   = shift;
  $self->base . '/NNML.spool';
}

sub bad {
  my $self   = shift;
  $self->base . '/NNML.bad';
}

sub active {
  my $self   = shift;
  my $active = shift;
  if (defined $active) {
    $self->{active} = $active;
    delete $self->{_active};
  }
  return $self->{_active} if exists $self->{_active};
  $self->{_active} = $self->{active};
  $self->{_active} =~ s/^~/$self->base/e;
  $self->{_active};
}

sub passwd {
  my $self = shift;
  my $passwd = shift;
  if (defined $passwd) {
    $self->{passwd} = $passwd;
    delete $self->{_passwd};
  }
  return $self->{_passwd} if exists $self->{_passwd};
  $self->{_passwd} = $self->{passwd};
  $self->{_passwd} =~ s/^~/$self->base/e;
  $self->{_passwd};
}

sub AUTOLOAD {
  my $func = $NNML::Config::AUTOLOAD; $func =~ s/.*:://;
  my $self = shift;
  my $val  = shift;
  if (defined $val) {
    $self->{$func} = $val;
    return $val;
  } else {
    if (exists $self->{$func}) {
      return $self->{$func};
    } else {
      return undef;
    }
  }
}

1;