File Coverage

blib/lib/Template/Plugin/DataHash.pm

Criterion	Covered	Total	%
statement	9	88	10.2
branch	0	32	0.0
condition	0	14	0.0
subroutine	3	12	25.0
pod	1	9	11.1
total	13	155	8.3

#!/usr/bin/perl -w

package Template::Plugin::DataHash;

use strict;

use vars qw($VERSION @ISA $EXTENSION $DEFAULT_INCLUDE_PATH);
$VERSION = '0.04';

use Template::Plugin;
@ISA = qw(Template::Plugin);
$EXTENSION = {
  perl     => qr/\.pl$/i,
  split    => qr/\.split$/i,
  storable => qr/\.sto$/i,
  xml      => qr/\.xml$/i,
  yaml     => qr/\.yaml$/i,
};

### $EXTENSION is a list of regular expression objects used to determine
### how to read in the given conf file

### if a INCLUDE_PATH isn't in the Template::Toolkit object, $DEFAULT_INCLUDE_PATH
### will be used as the INCLUDE_PATH
$DEFAULT_INCLUDE_PATH = ['/tmp'];

sub new {
  my $type  = shift;
  my $template_object = shift || {};

  my @PASSED_ARGS = (ref $_[0] eq 'HASH') ? %{$_[0]} : @_;
  my %DEFAULT_ARGS = (
    extension => {
      %{$EXTENSION},
    },
    extension_order => [qw(yaml perl storable xml split)],
  );
  my $self = bless \%DEFAULT_ARGS, $type;
  $self->merge_in_args(@_);
  unless($self->{INCLUDE_PATH}) {
    if($template_object->{CONFIG}{INCLUDE_PATH}) {
      $self->{INCLUDE_PATH} = [reverse @{$template_object->{CONFIG}{INCLUDE_PATH}}];
    } else {
      $self->{INCLUDE_PATH} = $DEFAULT_INCLUDE_PATH;
    }
  }
  return $self;
}

sub hash {
  my $self = shift;
  my $filename = shift;
  my $dirs = shift || $self->{INCLUDE_PATH};

  my $return = {};
  foreach my $dir (to_array($dirs)) {
    my $full_path = "$dir/$filename";
    next unless(-e $full_path);
    my $this_ref;
    foreach my $regex (@{$self->{extension_order}}) {
      if($full_path =~ $self->{extension}{$regex}) {
        my $method = "load_$regex";
        my $ref = $self->can($method);
        if($ref) {
          $this_ref = $self->$ref($full_path);
        } elsif($self->{$method}) {
          my $method_ref = ref $self->{$method};
          if($method_ref && $method_ref eq 'CODE') {
            $this_ref = &{$self->{$method}}($self, $full_path);
          } else {
            die "\$self->{$method_ref} needs to be a CODE ref";
          }
        } else {
          die "couldn't find a $method method to load $full_path";
        }
      }
    }
    die "conf file returned a non-hash ref" unless(ref $this_ref && ref $this_ref eq 'HASH');
    foreach (keys %{$this_ref}) {
      $return->{$_} = $this_ref->{$_};
    }
  }
  return $return;
}

sub to_array {
  my $values = shift;
  return () unless defined $values;
  if (ref $values eq "ARRAY") {
    return @$values;
  }
  return ($values);
}

sub merge_in_args {
  my $self = shift;
  my %PASSED_ARGS = (ref $_[0] eq 'HASH') ? %{$_[0]} : @_;
  foreach my $passed_arg (keys %PASSED_ARGS) {
    if(ref $PASSED_ARGS{$passed_arg} && ref $PASSED_ARGS{$passed_arg} eq 'HASH') {
      foreach my $key (keys %{$PASSED_ARGS{$passed_arg}}) {
        $self->{$passed_arg}{$key} = $PASSED_ARGS{$passed_arg}{$key};
      }
    } else {
      $self->{$passed_arg} = $PASSED_ARGS{$passed_arg}
    }
  }
}

sub load_yaml {
  my $self = shift;
  my $full_path = shift;
  require YAML;
  return YAML::LoadFile($full_path);
}

sub load_perl {
  my $self = shift;
  my $full_path = shift;
  return do $full_path;
}

sub load_storable {
  my $self = shift;
  my $full_path = shift;
  require Storable;
  return Storable::retrieve($full_path);
}
sub load_split {
  my $self = shift;
  my $full_path = shift;
  my $this_ref = {};
  open(FILE, $full_path) || die "couldn't open $full_path: $!";
  while() {
    next if(/^\s*#/);
    next unless(/^(\S+)\s+(.+)\n?/);
    $this_ref->{$1} = $2;
  }
  close(FILE);
  return $this_ref;
}

sub load_xml {
  my $self = shift;
  my $full_path = shift;
  require XML::Simple;
  return XML::Simple::XMLin($full_path);
}

1;

__END__