File Coverage

blib/lib/File/TVShow/Organize.pm

Criterion	Covered	Total	%
statement	181	184	98.3
branch	89	106	83.9
condition	23	35	65.7
subroutine	24	24	100.0
pod	15	15	100.0
total	332	364	91.2

package File::TVShow::Organize;

use 5.10.0;
use strict;
use warnings;
use Carp;
use File::Path qw(make_path);
use IPC::Cmd qw(can_run);
use File::Copy;
use File::TVShow::Info;

require Exporter;

our @ISA = qw(Exporter);

our $VERSION = '0.35';

# Preloaded methods go here.

sub new
{
  my ($class, $args) = @_;
  my $self = {
        #default data and states. Other data is created and stored during
        #program execution
        countries => "(UK|US)",
        delete => 0,
        verbose => 0,
        recursion => 0,
        seasonFolder => 1,
        exceptionListSource => $args->{Exceptions} || undef,
             };

  bless $self, $class;

  ## Additional constructor code goes here.

  if (!defined $self->{exceptionListSource}) {
  ## Do nothing
  } else {
    # create an array of pairs seperated by | character
    my @list1 = split /\|/, $self->{exceptionListSource};
    # now split each item in the array with by the : character use the first
    # value as the key and the second as value
    foreach my $item(@list1) {
      my ($key, $value) = split(/:/, $item);
      $self->{_exceptionList}{$key} = $value;
    }
  }
  return $self;
}

sub countries {

  # Set and get countries in case you want to change or add to the defaults
  # use | as your separator
  my ($self, $countries) = @_;
  $self->{countries} = $countries if defined $countries;
  return $self->{countries};
}

sub show_folder {
  # Set and get path for where new shows are to be stored in the file system
  my ($self, $path) = @_;
  if (defined $path) {
    if ((-e $path) and (-d $path)) {
      $self->{showFolder} = $path;
      # Append / if missing from path
      if ($self->{showFolder} !~ m/.*\/$/) {
        $self->{showFolder} = $self->{showFolder} . '/';
      }
    } else {
      $self->{showFolder} = undef;
    }
  }
  return $self->{showFolder};
}

sub new_show_folder {
  # Set and get path to find new files to be moved from live
  my ($self, $path) = @_;
  if (defined $path) {
    if ((-e $path) and (-d $path)) {
      $self->{newShowFolder} = $path;
      # Append / if missing from path
      if ($self->{newShowFolder} !~ m/.*\/$/) {
        $self->{newShowFolder} = $self->{newShowFolder} . '/';
      }
    } else {
      $self->{newShowFolder} = undef;
    }
  }
  return $self->{newShowFolder};
}

sub create_show_hash {

  my ($self) = @_;

  # exit loudly if the path has not been defined by the time this is called
  croak unless defined($self->{showFolder});

  # Get the root path of the TV Show folder
  my $directory = $self->show_folder();
  my $showNameHolder;

  opendir(DIR, $directory) or die $!;
  while (my $file = readdir(DIR)) {
    next if ($file =~ m/^\./); # skip hidden files and folders
    chomp($file); # trim and end of line character
    # create the inital hash strings are converted to lower case so
    # "Doctor Who (2005)" becomes
    # "doctor who (2005)" key="doctor who (2005), path="Doctor Who (2005)
    $self->{shows}{lc($file)}{path} = $file;
    # hanle if there is US or UK in the show name
    if ($file =~ m/\s\(?$self->{countries}\)?$/i) {
      $showNameHolder = $file;
      # name minus country in $1 country in $2
      $showNameHolder =~ s/(.*) \(?($self->{countries})\)?/$1/gi;
      #catinate them together again with () around country
      #This is now another key to the same path
      $self->{shows}{lc($showNameHolder . " ($2)")}{path} = $file;
      # create a key to the same path again with out country unless one has
      # been already defined by another show
      # this handles something like "Prey" which has a "Prey US" version
      # and "Prey UK"
      $self->{shows}{lc($showNameHolder)}{path} = $file unless (exists $self->{shows}{lc($showNameHolder)});
    }
    # Handle shows with Year extensions in the same manner has UK|USA
    if ($file =~ m/\s\(?\d{4}\)?$/i) {
      $showNameHolder = $file;
      $showNameHolder =~ s/(.*) \(?(\d\d\d\d)\)?/$1/gi;
      $self->{shows}{lc($showNameHolder . " ($2)")}{path} = $file;
      $self->{shows}{lc($showNameHolder . " $2")}{path} = $file;
      $self->{shows}{lc($showNameHolder)}{path} = $file unless
        (exists $self->{shows}{lc($showNameHolder)});
    }
  }
  closedir(DIR);
  # Does this need to return anything or can it just return $self
  return $self->{shows};

}

sub clear_show_hash {
  my ($self) = @_;

  $self->{shows} = ();
  return $self;
}

sub show_path {

  # Access the shows hash and return the correct directory path for the show
  # name as passed to the funtion
  my ($self, $show) = @_;
  return $self->{shows}{lc($show)}{path};
}

sub process_new_shows {

  my ($self, $curr_dir) = @_;
  $curr_dir = $self->new_show_folder() unless defined($curr_dir);

  my $destination;

  opendir(DIR, $curr_dir) or die $!;
  while (my $file = readdir(DIR)) {
    $destination = undef;
    ## Skip hiddenfiles
    next if ($file =~ m/^\./);
    ## Trim the file name incase of end of line marker
    chomp($file);
    ## Skip files that have been processed before. They have had .done appended
    # to to them.
    next if ($file =~ m/\.done$/);
    if (!$self->recursion) {
      next if -d $self->new_show_folder() . $file; ## Skip non-Files
    } else {
      $self->process_new_shows($curr_dir . $file . "/") if -d $curr_dir . $file;
    };
    # next if ($file !~ m/s\d\de\d\d/i); # skip if SXXEXX is not present in file name
    my $showData;
    # Extract show name, Season and Episode
    $showData = File::TVShow::Info->new($file);
    next if !$showData->is_tv_show();
    # Apply special handling if the show is in the _exceptionList
    if (exists $self->{_exceptionList}{$showData->{organize_name}}) { ##Handle special cases like "S.W.A.T"
      # Replace the original name value with the one found in _exceptionList
      $showData->{organize_name} = $self->{_exceptionList}{$showData->{organize_name}};
    } else {
      # Handle normally using '.' as the space marker name "Somthing.this" becomes "Something this"
      # Strip periods from name.
      $showData->{organize_name} =~ s/\./ /g;
    }

    # If we don't have a show_path skip. Probably an unhandled show name
    # store it in the UnhandledFileNames hash for reporting later.
    if (!defined $self->show_path($showData->{organize_name})) {
      $self->{UnhandledFileNames}{$file} = $showData->{organize_name};
      next;
    }
    # Create the path string for storing the file in the right place
    $destination = $self->show_folder() . $self->show_path($showData->{organize_name});
    # if this is true. Update the $destination and create the season subfolder if required.
    # if this is false. Do not append the season folder. files should just be stored in the root of the show folder.
    if($self->season_folder()) {
      $destination = $self->create_season_folder($destination, int($showData->{season}));
    };
    # Import the file. This will use rsync to copy the file into place and either rename or delete.
    # see move_show() for implementation details
    $self->move_show($destination, $curr_dir, $file);
  }
  close(DIR);
  return;
  #return $self;
}

sub were_there_errors {

  my ($self) = @_;

  # Check if there has been any files that File::TVShow::Info could not handle
  # Check that the hash UnHandledFileNames has actually been created before
  # checking that is is not empty or you will get an error.
  if ((defined $self->{UnhandledFileNames}) && (keys %{$self->{UnhandledFileNames}})) {
    print "\nThere were unhandled files in the directory\n";
    print "consider adding them to the exceptionList\n###\n";
    foreach my $key (keys %{$self->{UnhandledFileNames}}) {
      print "### " .  $key . " ==> " . $self->{UnhandledFileNames}{$key} . "\n";
    }
    print "###\n";
  }

  return $self;
}

sub delete {

  my ($self, $delete) = @_;

  return $self->{delete} if(@_ == 1);

  if (($delete =~ m/[[:alpha:]]/) || ($delete != 0) && ($delete != 1)) {
    print STDERR "Invalid arguments passed. Value not updated\n";
    return undef;
  } else {
    if ($delete == 1) {
      $self->{delete} = 1;
    } elsif ($delete == 0) {
      $self->{delete} = 0;
    }

    # This return seems like its on a branch of code that is of litle use.
    # Unless the return is checked on being set.

    return $self->{delete};
  }
}

sub recursion {

  my ($self, $recursion) = @_;

  return $self->{recursion} if(@_ == 1);

  if (($recursion =~ m/[[:alpha:]]/) || ($recursion != 0) && ($recursion != 1)) {
    print STDERR "Invalid arguments passed. Value not updated\n";
    return undef;
  } else {
    if ($recursion == 1) {
      $self->{recursion} = 1;
    } elsif ($recursion == 0) {
      $self->{recursion} = 0;
    }

    # This return seems like its on a branch of code that is of litle use.
    # Unless the return is checked on being set.
    return $self->{recursion};
  }
}

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

  return $self->{verbose} if(@_ == 1);

  if (($verbose =~ m/[[:alpha:]]/) || ($verbose != 0) && ($verbose != 1)) {
    print STDERR "\n### Invalid arguments passed. Value not updated\n";
    return undef;
  } else {
    if ($verbose == 1) {
      $self->{verbose} = 1;
    } elsif ($verbose == 0) {
      $self->{verbose} = 0;
    }
    # This return seems like its on a branch of code that is of litle use.
    # Unless the return is checked on being set.

    return $self->{verbose};
  }
}

sub season_folder {
   my ($self, $seasonFolder) = @_;

  return $self->{seasonFolder} if(@_ == 1);

  if (($seasonFolder =~ m/[[:alpha:]]/) || ($seasonFolder != 0) && ($seasonFolder != 1)) {
    print STDERR "\n### Invalid arguments passed. Value not updated\n";
    return undef;
  } else {
    if ($seasonFolder == 1) {
      $self->{seasonFolder} = 1;
    } elsif ($seasonFolder == 0) {
      $self->{seasonFolder} = 0;
    }
    # This return seems like its on a branch of code that is of litle use.
    # Unless the return is checked on being set.
    return $self->{seasonFolder};
  }
}

sub create_season_folder {

  my ($self, $_path, $season) = @_;

  my $path = $_path .  '/';

  if ($season == 0) {
    $path = $path . 'Specials'
  } else {
    $path = $path . 'Season' . $season;
  }
  # Show Season folder being created if verbose mode is true.
  if($self->verbose) {
    make_path($path, { verbose => 1 }) unless -e $path;
  } else {
    # Verbose mode is false so work silently.
    make_path($path) unless -e $path;
  }
  return $path;
}


sub move_show {

  my ($self, $destination, $source, $file) = @_;

  # If the destination folder or source filder are not defined or no file is
  # passed exit with errors
  carp "Destination not passed." unless defined($destination);
  carp "Source not passed." unless defined($source);
  carp "File not passed." unless defined($file);

  # rewrite paths so they are rsync friendly. This means escape spaces and
  # other special characters.
  ($destination, $source) = _rsync_prep ($destination,$source);

  # create the command string to be used in system() call
  # Set --progress if verbose is true

  # Get path to rsync using IPC::Cmd
  my $command = can_run('rsync');
  $command .=  " -ta ";
  $command = $command . "--progress " if ($self->verbose);
  $command = $command . $source . $file . " " . $destination;

  system($command);

  if($? == 0) {
    # If delete is true unlink file.
    if($self->delete) {
      unlink($source . $file);
    } else {
      # delete is false so merely rename the file by appending .done
      move($source . $file, $source . $file . ".done")
    }
  } else {
    #report failed processing? Error on rsync command return code
    print "## Something went very wrong. Rsync failed for some reason.\n";
    print "## rsync err $?\n";
  }
  return $self;

}

# This interal sub-routine prepares paths for use with external rsynch command
# Need to escape special characters
sub _rsync_prep  {

  my ($dest, $source) = @_;

  # escape spaces and () characters to work with the rsync command.
  $dest =~ s/\(/\\(/g;
  $dest =~ s/\)/\\)/g;
  $dest =~ s/ /\\ /g;
  $dest = $dest . "/";

  $source =~ s/ /\\ /g;
  #$source = $source . "/";

  return $dest, $source;
}

1;


__END__