feat: implement double octave guitar pitch line

src/Domain/Guitar.ts

@@ -664,6 +664,16 @@ export class GuitarPitchLine implements Iterable<Fret> {
   }
 }
 
+export class DoubleOctaveGuitarPitchLine extends GuitarPitchLine {
+  constructor(
+    pitchLine: PitchLine,
+    position: Position,
+    guitarStrings: GuitarStrings = new GuitarStrings()
+  ) {
+    super(pitchLine.addOctave(), position, guitarStrings);
+  }
+}
+
 export class GuitarHarmonicLine implements Iterable<GuitarChord> {
   private readonly chords: GuitarChord[] = [];
   private readonly bassString: GuitarString = GuitarString.Sixth;

src/Domain/Pitch.ts

@@ -529,10 +529,14 @@ export const enum PitchLineDirection {
 
 export class PitchLine implements Iterable<Pitch> {
   constructor(
-    private readonly line: Pitch[] = [],
+    private line: Pitch[] = [],
     private readonly direction: PitchLineDirection = PitchLineDirection.Ascending
   ) {}
 
+  addOctave(): PitchLine {
+    return new PitchLine(this.line.concat(this.line), this.direction);
+  }
+
   get Direction(): PitchLineDirection {
     return this.direction;
   }

src/Domain/Scale.ts

@@ -286,11 +286,11 @@ export class ScalePattern {
   }
 
   public createPitchLineScale(root: Pitch): PitchLine {
-    return this.createScale(root).MelodicLine;
+    return this.createScale(root).PitchLine;
   }
 
   public createDescendingPitchLineScale(root: Pitch): PitchLine {
-    return this.createScale(root).DescendingMelodicLine;
+    return this.createScale(root).DescendingPitchLine;
   }
 
   public get Name(): string {
@@ -319,11 +319,11 @@ export class Scale implements Iterable<Pitch> {
     private readonly pitches: Pitch[] = scalePattern.createScalePitches(root)
   ) {}
 
-  get MelodicLine(): PitchLine {
+  get PitchLine(): PitchLine {
     return new PitchLine(this.pitches, PitchLineDirection.Ascending);
   }
 
-  get DescendingMelodicLine(): PitchLine {
+  get DescendingPitchLine(): PitchLine {
     return new PitchLine(this.pitches, PitchLineDirection.Descending);
   }
 

src/__test__/Domain/Guitar.tab.test.ts

@@ -1,6 +1,7 @@
 import { Chord, ChordPattern, ClosedChord } from '../../Domain/Chord';
 import {
   BlankFret,
+  DoubleOctaveGuitarPitchLine,
   Fret,
   GuitarChord,
   GuitarHarmonicLine,
@@ -12,6 +13,7 @@ import {
   TabColumn,
 } from '../../Domain/Guitar';
 import { Pitch, PitchLine, PitchLineDirection } from '../../Domain/Pitch';
+import { ScalePattern } from '../../Domain/Scale';
 
 describe('Blank fret should', () => {
   test('render empty column', () => {
@@ -127,10 +129,6 @@ E|-10-|`;
         const line = new PitchLine([Pitch.C, Pitch.E, Pitch.G]);
         const guitarLine = new GuitarPitchLine(line, Position.C);
 
-        expect(Array.from(guitarLine)[0]).toStrictEqual(new Fret(GuitarString.Fifth, 3));
-        expect(Array.from(guitarLine)[1]).toStrictEqual(new Fret(GuitarString.Fourth, 2));
-        expect(Array.from(guitarLine)[2]).toStrictEqual(new Fret(GuitarString.Fourth, 5));
-
         const renderedTab = Tab.render(guitarLine.toTab());
 
         const expectedTab = `e|-------|
@@ -139,21 +137,15 @@ G|-------|
 D|---2-5-|
 A|-3-----|
 E|-------|`;
-
         expect(renderedTab).toBe(expectedTab);
       });
 
       test('C E G descending on C position', () => {
         const line = new PitchLine([Pitch.C, Pitch.E, Pitch.G], PitchLineDirection.Descending);
-        expect(line).toBeTruthy();
-
         const guitarLine = new GuitarPitchLine(line, Position.C);
 
-        expect(Array.from(guitarLine)[0]).toStrictEqual(new Fret(GuitarString.First, 3));
-        expect(Array.from(guitarLine)[1]).toStrictEqual(new Fret(GuitarString.Second, 5));
-        expect(Array.from(guitarLine)[2]).toStrictEqual(new Fret(GuitarString.Second, 1));
-
         const renderedTab = Tab.render(guitarLine.toTab());
+
         const expectedTab = `e|-3-----|
 B|---5-1-|
 G|-------|
@@ -162,6 +154,66 @@ A|-------|
 E|-------|`;
         expect(renderedTab).toBe(expectedTab);
       });
+
+      test('C major scale ascending on C position', () => {
+        const line = ScalePattern.Ionian.createPitchLineScale(Pitch.C);
+        const guitarLine = new GuitarPitchLine(line, Position.C);
+
+        const renderedTab = Tab.render(guitarLine.toTab());
+
+        const expectedTab = `e|---------------|
+B|---------------|
+G|-----------2-4-|
+D|-----2-3-5-----|
+A|-3-5-----------|
+E|---------------|`;
+        expect(renderedTab).toBe(expectedTab);
+      });
+
+      test('C mixolydian scale ascending on C position', () => {
+        const line = ScalePattern.Mixolydian.createPitchLineScale(Pitch.C);
+        const guitarLine = new GuitarPitchLine(line, Position.C);
+
+        const renderedTab = Tab.render(guitarLine.toTab());
+
+        const expectedTab = `e|---------------|
+B|---------------|
+G|-----------2-3-|
+D|-----2-3-5-----|
+A|-3-5-----------|
+E|---------------|`;
+        expect(renderedTab).toBe(expectedTab);
+      });
+
+      test('C mixolydian scale ascending on C position 2 octaves', () => {
+        const line = ScalePattern.Mixolydian.createPitchLineScale(Pitch.C);
+        const guitarLine = new DoubleOctaveGuitarPitchLine(line, Position.C);
+
+        const renderedTab = Tab.render(guitarLine.toTab());
+
+        const expectedTab = `e|---------------------1-3-5-|
+B|-----------------3-5-------|
+G|-----------2-3-5-----------|
+D|-----2-3-5-----------------|
+A|-3-5-----------------------|
+E|---------------------------|`;
+        expect(renderedTab).toBe(expectedTab);
+      });
+
+      test('D mixolydian scale ascending on C position 2 octaves', () => {
+        const line = ScalePattern.Mixolydian.createPitchLineScale(Pitch.D);
+        const guitarLine = new DoubleOctaveGuitarPitchLine(line, Position.C);
+
+        const renderedTab = Tab.render(guitarLine.toTab());
+
+        const expectedTab = `e|-------------------2-3-5-|
+B|---------------3-5-------|
+G|---------2-4-5-----------|
+D|---2-4-5-----------------|
+A|-5-----------------------|
+E|-------------------------|`;
+        expect(renderedTab).toBe(expectedTab);
+      });
     });
 
     describe('chord', () => {