File Coverage

blib/lib/LyricFinder.pm

Criterion	Covered	Total	%
statement	33	164	20.1
branch	0	56	0.0
condition	0	48	0.0
subroutine	11	16	68.7
pod	4	4	100.0
total	48	288	16.6

package LyricFinder;

require 5.001;

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

# LyricFinder - A Derived work, by (c) 2020-2026 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.60';
our $DEBUG = 0;  # If you want debug messages, set debug to a true value

my @supported_mods = (qw(Cache ApiLyricsOvh AZLyrics Genius Letras Lrclib 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);
	unless (ref $fetcherspec)
	{
		$fetcherspec = 'random'  unless ($fetcherspec =~ /\w/);
		$fetcherspec = [split /\s*\,\s*/, $fetcherspec],
	}
	$fetcherspec = ['random']  unless ($#{$fetcherspec} >= 0);
	if ($#{$fetcherspec} > 0) {
		my $specstring = join('|',@{$fetcherspec});
		if ($specstring =~ /\b(Cache|auto|all)\b/i) {
			carp("s:'$1' can only be used by itself, not in a list!");
			return;
		}
	}
	$self->{'Source'} = 'none';

	# we've got an arrayref of fetchers to use:
	my %usedSources = ();  #avoid including any module name more than once in the list.
	for my $fetcher (@{$fetcherspec}) {
		if (grep /$fetcher/, @{$self->{'_FETCHERS'}}) {  #VALID FETCHER(S) SPECIFIED:
			push @tryfetchers, $fetcher;
			$usedSources{$fetcher} = 1;
		} elsif ($fetcher =~ m'^random$'i) {  #"random" SPECIFIED (CONVERTS TO A RANDOM LIST OF FETCHERS:
			my $random_fetcher;
			my $usedcnt = 0;
			foreach my $t (@tryfetchers) {
				$usedSources{$t} = 1;
				++$usedcnt;
			}
			my $fetchersCnt = scalar(@{$self->{'_FETCHERS'}});
			my $maxcnt = ($fetchersCnt - $#{$fetcherspec}) + $usedcnt;
			$maxcnt -= ($fetchersCnt - $limit)  if (defined($limit) && $limit > 0 && $fetchersCnt > $limit);

			#NOTE:  usedcnt = # OF ITEMS (IF ANY) SPECIFIED LEFT OF "random"!
			while (scalar(@tryfetchers) < $maxcnt) {
				$random_fetcher = int(rand(scalar @{$self->{'_FETCHERS'}}));
				unless ($usedSources{${$self->{'_FETCHERS'}}[$random_fetcher]}
						|| grep(/${$self->{'_FETCHERS'}}[$random_fetcher]/, @{$fetcherspec})) {
					push @tryfetchers, ${$self->{'_FETCHERS'}}[$random_fetcher];
					$usedSources{${$self->{'_FETCHERS'}}[$random_fetcher]} = 1;
					$usedcnt++;
				}
			}
		} elsif ($fetcher =~ m'^Cache$'i && $haveit{'Cache'}) {  #The Cache MODULE SPECIFIED:
			@tryfetchers = ('Cache');
			last;  #these values can only be used once (first) & by itself!
		} elsif ($fetcher =~ m'^A(?:uto|ll)$'i) {  #"auto" or "all" SPECIFIED (SYNONYMS):
			@tryfetchers = @{$self->{'_FETCHERS'}};
			last;
		} else {   #INVALID MODULE-NAME OR VALUE SPECIFIED, SKIP:
			carp("e:$fetcher isn't a valid fetcher, ignoring");
		}
	}
	$#tryfetchers = $limit - 1  if (defined($limit) && $limit > 0 && $limit <= $#tryfetchers);
	unless ($#tryfetchers >= 0)	{  #NO VALID MODULE NAMES S SPECIFIED (PUNT)!:
		carp("s:No valid fetchers specified!")  ;
		return;
	}

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

1

__END__