File Coverage

blib/lib/Music/ScaleNote.pm

Criterion	Covered	Total	%
statement	70	70	100.0
branch	23	34	67.6
condition	22	32	68.7
subroutine	10	10	100.0
pod	2	2	100.0
total	127	148	85.8

package Music::ScaleNote;
our $AUTHORITY = 'cpan:GENE';

# ABSTRACT: Manipulate the position of a note in a scale

our $VERSION = '0.0704';

use strictures 2;
use Carp qw(croak);
use List::Util qw( first );
use Moo;
use Music::Note ();
use Music::Scales qw(get_scale_notes);
use namespace::clean;


has scale_note => (
    is      => 'ro',
    default => sub { 'C' },
);


has scale_name => (
    is      => 'ro',
    default => sub { 'major' },
);


has note_format => (
    is      => 'ro',
    default => sub { 'ISO' },
);


has offset => (
    is      => 'ro',
    isa     => sub { die 'Not a negative or positive integer' unless $_[0] =~ /^-?\d+$/ },
    default => sub { 1 },
);


has flat => (
    is      => 'ro',
    default => sub { 0 },
);


has verbose => (
    is      => 'ro',
    default => sub { 0 },
);


sub get_offset {
    my ( $self, %args ) = @_;

    my $name   = $args{note_name};
    my $format = $args{note_format} || $self->note_format;
    my $offset = $args{offset} || $self->offset;
    my $flat   = $args{flat} || $self->flat;

    croak 'note_name, note_format or offset not provided'
        unless $name || $format || $offset;

    my $rev;  # Going in reverse?

    my $note = Music::Note->new( $name, $format );

    my $equiv;
    if ( $note->format('isobase') =~ /b/ || $note->format('isobase') =~ /#/ ) {
        $equiv = Music::Note->new( $name, $format );
        $equiv->en_eq( $note->format('isobase') =~ /b/ ? 'sharp' : 'flat' );
    }

    printf "Given note: %s, ISO: %s/%s, Offset: %d\n",
        $name, $note->format('ISO'), ( $equiv ? $equiv->format('ISO') : '' ), $offset
        if $self->verbose;

    my @scale = get_scale_notes( $self->scale_note, $self->scale_name );
    print "\tScale: @scale\n"
        if $self->verbose;

    if ( $offset < 0 ) {
        $rev++;
        $offset = abs $offset;
        @scale  = reverse @scale;
    }

    my $posn = first {
        ( $scale[$_] eq $note->format('isobase') )
        ||
        ( $equiv && $scale[$_] eq $equiv->format('isobase') )
    } 0 .. $#scale;

    if ( defined $posn ) {
        printf "\tPosition: %d\n", $posn
            if $self->verbose;
        $offset += $posn;
    }
    else {
        croak 'Scale position not defined!';
    }

    my $octave = $note->octave;
    my $factor = int( $offset / @scale );

    if ( $rev ) {
        $octave -= $factor;
    }
    else {
        $octave += $factor;
    }

    $note = Music::Note->new( $scale[ $offset % @scale ] . $octave, 'ISO' );

    if ( $flat && $note->format('isobase') =~ /#/ ) {
        $note->en_eq('flat');
    }

    printf "\tNew offset: %d, octave: %d, ISO: %s, Formatted: %s\n",
        $offset, $octave, $note->format('ISO'), $note->format($format)
        if $self->verbose;

    return $note;
}


sub step {
    my ( $self, %args ) = @_;

    my $name  = $args{note_name};
    my $steps = $args{steps} || 1;
    my $flat  = $args{flat} || $self->flat;

    croak 'note_name not provided'
        unless $name;

    my $note = Music::Note->new( $name, $self->note_format );
    my $num  = $note->format('midinum');

    printf "Given note: %s, ISO: %s, Formatted: %d\n",
        $name, $note->format('ISO'), $num
        if $self->verbose;

    $num += $steps;
    $note = Music::Note->new( $num, 'midinum' );

    if ( $flat && $note->format('isobase') =~ /#/ ) {
        $note->en_eq('flat');
    }

    printf "\tNew steps: %d, ISO: %s, Formatted: %s\n",
        $steps, $note->format('ISO'), $note->format( $self->note_format )
        if $self->verbose;

    return $note;
}

1;

__END__