File Coverage

blib/lib/Music/ScaleNote.pm

Criterion	Covered	Total	%
statement	72	72	100.0
branch	14	22	63.6
condition	22	35	62.8
subroutine	14	14	100.0
pod	2	2	100.0
total	124	145	85.5

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

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

our $VERSION = '0.0900';

use Moo;
use strictures 2;
use Carp qw(croak);
use Data::Dumper::Compact qw( ddc );
use Array::Circular ();
use List::SomeUtils qw( first_index );
use MIDI::Util qw(midi_format);
use Music::Note ();
use Music::Scales qw( get_scale_notes get_scale_nums );
use namespace::clean;


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


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

has _scale => (
    is      => 'lazy',
    builder => '_build__scale',
);
sub _build__scale {
    my ($self) = @_;
    my @base = get_scale_nums( $self->scale_name );
    my @scale;
    for my $i (0 .. 9) {
        for my $degree (@base) {
            push @scale, $degree + ($i * 12)
        }
    }
    # print ddc \@scale;
    return \@scale;
}


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


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}   || $self->scale_note;
    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 $note = Music::Note->new( $name, $format );
    croak 'Note not defined!' unless $note->format($format) eq $name;

    my $octave = $note->octave;

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

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

    my $posn = first_index { $note->format('midinum') == $_ } @{ $self->_scale };
    if ( $posn >= 0 ) {
        printf "\tPosition: %d, Offset position: %d\n", $posn, $posn + $offset
            if $self->verbose;
    }
    else {
        croak 'Scale position not defined!';
    }

    my $n = $self->_scale->[ $posn + $offset ];
    $note = Music::Note->new( $n, 'midinum' );

    $note->en_eq('flat') if $flat;

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

    return $note;
}


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

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

    my $note = Music::Note->new( $name, $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' );
    $note->en_eq('flat') if $flat && $note->format('isobase') =~ /#/;

    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__