File Coverage

blib/lib/LyricFinder.pm

Criterion	Covered	Total	%
statement	30	141	21.2
branch	0	48	0.0
condition	0	48	0.0
subroutine	10	15	66.6
pod	4	4	100.0
total	44	256	17.1

package LyricFinder;

require 5.001;

use strict;
use warnings;
use Carp;
use parent 'LyricFinder::_Class';

# LyricFinder - A Derived work, by (c) 2020 Jim Turner  of:
#
# Lyrics Fetcher
#
# Copyright (C) 2007-2020 David Precious  (CPAN: BIGPRESH)
#
# Originally authored by and copyright (C) 2003 Sir Reflog
# who kindly passed maintainership on to David Precious in Feb 2007
#
# Original idea:
# Copyright (C) 2003 Zachary P. Landau
# All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

our $VERSION = '1.21';
our $DEBUG = 0;  # If you want debug messages, set debug to a true value

my @supported_mods = (qw(Cache ApiLyricsOvh AZLyrics Genius Letras Musixmatch));

my %haveit;

foreach my $module (@supported_mods)
{
	$haveit{$module} = 0;
	eval "use LyricFinder::$module; \$haveit{$module} = 1; 1";
}

sub new
{
	my $class = shift;

	#EXTRACT ANY MAIN-SPECIFIC ARGUMENTS (NOT TO BE PASSED TO SUBMODULES):
	my @args = ();
	while (@_) {
		my $arg = shift(@_);
		if ($arg =~ /^\-omit$/o) {   #ALLOW USER TO OMIT SPECIFIC INSTALLED SUBMODULE(S):
			my $omit = shift(@_);
			my @omitModules = ref($omit) ? @{$omit} : split(/\,\s*/, $omit);
			foreach my $omit (@omitModules)
			{
				$haveit{$omit} = 0  if (defined($haveit{$omit}) && $haveit{$omit});
			}
		} else {
			push @args, $arg;
		}
	}

	my $self = $class->SUPER::new('', @args);
#	@{$self->{'_fetchers'}} = @FETCHERS;
	@{$self->{'_fetchers'}} = ();
	@{$self->{'_FETCHERS'}} = ();
	#NOTE:  UPPER CASE _FETCHERS USED FOR "random" AND "all", & *NEVER* INCLUDES CACHE (1ST SUBMODULE TRIES CACHE)!:
	#LOWER CASE _fetchers INCLUDES CACHE FIRST IF CACHE DIRECTORY AND IT'S NOT WRITEONLY, AS THIS IS FOR ORDER/TRIED LIST!
	foreach my $module (@supported_mods)
	{
		next  unless ($haveit{$module} && $module ne 'Cache');
		push @{$self->{'_FETCHERS'}}, $module;
		push @{$self->{'_fetchers'}}, $module;
	}

	unshift(@{$self->{'_fetchers'}}, 'Cache')  if ($haveit{'Cache'}
			&& $self->{'-cache'} && $self->{'-cache'} !~ /^\>/);

	bless $self, $class;   #BLESS IT!

	return $self;
}

sub order {
	my $self = shift;
	return wantarray ? split(/\,/, $self->{'Order'}) : $self->{'Order'};
}

sub tried {
	my $self = shift;
	return wantarray ? split(/\,/, $self->{'Tried'}) : $self->{'Tried'};
}

sub _fetch {
	my ($self, $artist, $title, $fetchers) = @_;

	$self->_debug("LyricFinder::_fetch($artist, $title, $fetchers)!");
	if (!$artist || !$title || ref $artist || ref $title) {
		carp("e:_fetch() called without artist and title.");
		return;
	}

	if (!$fetchers || ref $fetchers ne 'ARRAY') {
		carp("e:_fetch not given arrayref of fetchers to try");
		return;
	}

	for my $fetcher (@$fetchers) {
		$self->{'Url'} = '';
		$self->_debug("..Trying fetcher $fetcher for artist:$artist title:$title");

		my $fetcherpkg = __PACKAGE__ . "::$fetcher";
		my $finderModule = 0;
		eval "\$finderModule = new ${fetcherpkg}(\%{\$self});";
		if ($@ || !$finderModule) {
			carp("w:Failed to load sub-module $fetcherpkg ($@)");
			next;
		}

		# OK, we require()d this fetcher, try using it:
		$self->{'Error'} = 'Ok';
		$self->_debug("..Source module $fetcher loaded OK");
		$self->{'Tried'} .= "$fetcher,";
		if (!$finderModule->can('fetch')) {
			$self->_debug("e:Source LyricFinder::$fetcher can't ->fetch($finderModule->{'Error'})");
			next;
		}

		$self->_debug("..Trying to fetch with $fetcher");
		my $lyrics = $finderModule->fetch($artist, $title);
		$self->{'Error'} = $finderModule->message();
		$self->{'Url'} = $finderModule->url();
		if ($self->{'Error'} eq 'Ok') {
			$self->_debug("..Source: $fetcher returned lyrics");
			if (defined($lyrics) && $lyrics =~ /\S/o) {
				$self->{'Source'} = $finderModule->source();;
				$self->{'Site'} = $finderModule->site();
				$self->{'image_url'} = $finderModule->image_url();
				@{$self->{'Credits'}} = $finderModule->credits();
				$self->{'Tried'} =~ s/\,$//;
				$self->_debug("i:Lyrics fetched from: ".$self->{'Source'});

				return $lyrics;
			}
		}
	}

	# if we get here, we tried all sites we were asked to try, and none
	# of them worked.
	$self->{'Error'} = 'e:All sites failed to fetch lyrics!'  if ($#{$fetchers} > 0);
	$self->{'Tried'} =~ s/\,$//;

	return undef;
}

sub fetch {
	my ($self, $artist, $title, $fetcherspec, $limit) = @_;

	my @tryfetchers = ();

	$self->_debug("LyricFinder::fetch($artist, $title, $fetcherspec)!");
	$self->{'Tried'} = '';

	$fetcherspec = 'random'  unless (defined($fetcherspec) && $fetcherspec);
	$self->{'Source'} = 'none';
	if ( $fetcherspec && !ref $fetcherspec && $fetcherspec !~ m'^auto$'i) {
		# we've been given a specific fetcher to use:
		if (grep /$fetcherspec/, @{$self->{'_FETCHERS'}}) {
			push @tryfetchers, $fetcherspec;
		} elsif ($fetcherspec =~ m'^random$'i) {
			my $random_fetcher;
			my %usedSources = ();
			my $usedcnt = 0;
			while ($usedcnt <= $#{$self->{'_FETCHERS'}}) {
				$random_fetcher = int(rand(scalar @{$self->{'_FETCHERS'}}));
				unless ($usedSources{${$self->{'_FETCHERS'}}[$random_fetcher]}) {
					push @tryfetchers, ${$self->{'_FETCHERS'}}[$random_fetcher];
					$usedSources{${$self->{'_FETCHERS'}}[$random_fetcher]} = 1;
					$usedcnt++;
				}
			}
		} elsif ($fetcherspec =~ m'^Cache$'i && $haveit{'Cache'}) {
			@tryfetchers = ('Cache');
		} elsif ($fetcherspec =~ m'^All$'i) {
			push @tryfetchers, @{$self->{'_FETCHERS'}};
		} else {
			carp($self->{'Error'} = "s:Source (module) $fetcherspec isn't installed or is invalid!");
			return;
		}
	} elsif (ref $fetcherspec eq 'ARRAY') {
		# we've got an arrayref of fetchers to use:
		for my $fetcher (@$fetcherspec) {
			if (grep /$fetcher/, @{$self->{'_FETCHERS'}}) {
				push @tryfetchers, $fetcher;
			} else {
				carp("e:$fetcher isn't a valid fetcher, ignoring");
			}
		}
	} else {  #really shouldn't end up here (since default=random now), but leaving in for now.
		# OK, try all available fetchers.
		push @tryfetchers, @{$self->{'_FETCHERS'}};
	}
	$self->{'Order'} = join(',', @tryfetchers);
	$#tryfetchers = $limit - 1  if (defined($limit) && $limit > 0 && $limit < scalar(@tryfetchers));

	return $self->_fetch($artist, $title, \@tryfetchers);
}   # end of sub fetch.

1

__END__