9701182518

Committed 27 Jun 2024 05:43PM UTC coverage: 97.115% (-0.04%) from 97.152%

Build # 9701182518

Build Type

push

github

Committed by

pedromsantos

Commit Message

feat: fix errors with octave shifting in PitchLine to MelodicLine

Run Details

259 of 274 branches covered (94.53%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

1660 of 1702 relevant lines covered (97.53%)

440.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.92

/src/Domain/Barry.ts

import { Duration } from './Duration';
import { MelodicLine, Octave } from './Note';
import { Pitch, PitchLine, PitchLineDirection } from './Pitch';
import { Scale, ScaleDegree, ScalePattern } from './Scale';

export class PitchLines implements Iterable<PitchLine> {
  constructor(private readonly lines: PitchLine[] = []) {}

  add(line: PitchLine) {
    this.lines.push(line);
  }

  addPitch(pitch: Pitch) {
    this.lines[this.lines.length - 1]?.push(pitch);
  }

  lastPitch() {
    const lastLine = this.lines[this.lines.length - 1];

    if (lastLine) {
      return lastLine.lastPitch();
    }

    return undefined;
  }

  melodicLine(startingOctave: Octave, pitchDurations: Duration) {
    let octave = startingOctave;
    const melodicLine = new MelodicLine([]);

    for (const line of this.lines) {
      octave = melodicLine.lastOctave() ?? startingOctave;
      melodicLine.concat(line.toMelodicLine(octave, pitchDurations));
    }

    return melodicLine;
  }

  flatPitches() {
    return this.lines.flatMap((l) => [...l]);
  }

  *[Symbol.iterator](): Iterator<PitchLine> {
    for (const line of this.lines) {
      yield line;
    }
  }
}

class BarryHalfStepRule {
  private constructor(
    private readonly startDegree: ScaleDegree,
    private readonly endDegree: ScaleDegree
  ) {}

  public static readonly RootAndSeventh = new BarryHalfStepRule(ScaleDegree.I, ScaleDegree.VII);
  public static readonly SecondAndRoot = new BarryHalfStepRule(ScaleDegree.II, ScaleDegree.I);
  public static readonly ThirdAndSecond = new BarryHalfStepRule(ScaleDegree.III, ScaleDegree.II);
  public static readonly SixthAndFifth = new BarryHalfStepRule(ScaleDegree.VI, ScaleDegree.V);

  apply(line: PitchLine, scale: Scale) {
    line.insertHalfToneBetween(scale.pitchFor(this.startDegree), scale.pitchFor(this.endDegree));
  }
}

class BarryHalfStepRules {
  private static readonly all: BarryHalfStepRules[] = [];

  private constructor(
    private chordTonesMin: BarryHalfStepRule[],
    private noChordTonesMin: BarryHalfStepRule[],
    private chordTonesMax: BarryHalfStepRule[],
    private noChordTonesMax: BarryHalfStepRule[],
    private applyesTo: (scale: Scale) => boolean
  ) {
    BarryHalfStepRules.all.push(this);
  }

  public static readonly Dominant: BarryHalfStepRules = new BarryHalfStepRules(
    [BarryHalfStepRule.RootAndSeventh],
    [],
    [
      BarryHalfStepRule.RootAndSeventh,
      BarryHalfStepRule.SecondAndRoot,
      BarryHalfStepRule.ThirdAndSecond,
    ],
    [BarryHalfStepRule.RootAndSeventh, BarryHalfStepRule.SecondAndRoot],
    (scale: Scale) => scale.hasPattern(ScalePattern.Mixolydian)
  );

  public static readonly Major: BarryHalfStepRules = new BarryHalfStepRules(
    [BarryHalfStepRule.SixthAndFifth],
    [],
    [
      BarryHalfStepRule.SecondAndRoot,
      BarryHalfStepRule.ThirdAndSecond,
      BarryHalfStepRule.SixthAndFifth,
    ],
    [BarryHalfStepRule.RootAndSeventh, BarryHalfStepRule.SixthAndFifth],
    (scale: Scale) => scale.hasPattern(ScalePattern.Ionian)
  );

  public static readonly Minor: BarryHalfStepRules = new BarryHalfStepRules(
    [BarryHalfStepRule.SixthAndFifth],
    [],
    [
      BarryHalfStepRule.SecondAndRoot,
      BarryHalfStepRule.ThirdAndSecond,
      BarryHalfStepRule.SixthAndFifth,
    ],
    [BarryHalfStepRule.RootAndSeventh, BarryHalfStepRule.SixthAndFifth],
    (scale: Scale) => scale.hasPattern(ScalePattern.HarmonicMinor)
  );

  public static readonly Default: BarryHalfStepRules = new BarryHalfStepRules(
    [],
    [],
    [],
    [],
    () => false
  );

  static barryRulesFor(scale: Scale) {
    return (
      BarryHalfStepRules.all.find((rule) => rule.applyesTo(scale)) || BarryHalfStepRules.Default
    );
  }

  applyMin(scale: Scale, from: ScaleDegree, to: ScaleDegree) {
    const line = scale.down(from, to);

    if (this.lineStartsAtChordTone(from)) {
      for (const rule of this.chordTonesMin) {
        rule.apply(line, scale);
      }

      return line;
    }

    for (const rule of this.noChordTonesMin) {
      rule.apply(line, scale);
    }

    return line;
  }

  applyMax(scale: Scale, from: ScaleDegree, to: ScaleDegree) {
    const line = scale.down(from, to);

    if (this.lineStartsAtChordTone(from)) {
      for (const rule of this.chordTonesMax) {
        rule.apply(line, scale);
      }

      return line;
    }

    for (const rule of this.noChordTonesMax) {
      rule.apply(line, scale);
    }

    return line;
  }

  private lineStartsAtChordTone(degree: ScaleDegree) {
    return !!(
      degree === ScaleDegree.I ||
      degree === ScaleDegree.III ||
      degree === ScaleDegree.V ||
      degree === ScaleDegree.VII
    );
  }
}

export class BarryHarrisLine {
  private readonly line: PitchLines;

  constructor(private readonly scale: Scale) {
    this.line = new PitchLines();
  }

  arpeggioUpFrom(degree: ScaleDegree) {
    const arpeggio = new PitchLine(
      this.scale.thirdsFrom(degree).slice(0, 4),
      PitchLineDirection.Ascending
    );

    this.line.add(arpeggio);

    return this;
  }

  arpeggioUpFromLastPitch() {
    const from = this.lastDegree();

    if (from) {
      const arpeggio = new PitchLine(
        this.scale.thirdsFrom(from).slice(1, 4),
        PitchLineDirection.Ascending
      );

      this.line.add(arpeggio);
    }

    return this;
  }

  pivotArpeggioUpFrom(degree: ScaleDegree) {
    const arpeggio = this.scale.thirdsTo(degree).slice(0, 4);
    this.createPivotArpeggioLine(arpeggio, 0, 1);
    return this;
  }

  pivotArpeggioUpFromLastPitch() {
    const from = this.lastDegree();

    if (from) {
      const arpeggio = this.scale.thirdsTo(from).slice(0, 4);
      this.createPivotArpeggioLine(arpeggio, 1, 2);
    }

    return this;
  }

  resolveTo(pitch: Pitch) {
    this.line.add(
      new PitchLine(
        [pitch],
        this.line.lastPitch()! > pitch
          ? PitchLineDirection.Descending
          : PitchLineDirection.Ascending
      )
    );
    return this;
  }

  scaleDown(to: ScaleDegree, from: ScaleDegree) {
    this.line.add(BarryHalfStepRules.barryRulesFor(this.scale).applyMin(this.scale, from, to));

    return this;
  }

  scaleDownExtraHalfSteps(to: ScaleDegree, from: ScaleDegree) {
    this.line.add(BarryHalfStepRules.barryRulesFor(this.scale).applyMax(this.scale, from, to));

    return this;
  }

  scaleDownFromLastPitchTo(to: ScaleDegree) {
    const from = this.lastDegree();

    if (from) {
      this.scaleDown(to, from - 1);
    }

    return this;
  }

  scaleDownExtraHalfStepsFromLastPitch(to: ScaleDegree) {
    const from = this.lastDegree();

    if (from) {
      this.scaleDownExtraHalfSteps(to, from - 1);
    }

    return this;
  }

  build(startingOctave: Octave, pitchDurations: Duration) {
    let octave = startingOctave;
    const melodicLine = new MelodicLine([]);

    for (const line of this.line) {
      octave = melodicLine.lastOctave() ?? startingOctave;
      melodicLine.concat(line.toMelodicLine(octave, pitchDurations));
    }

    return melodicLine;
  }

  buildPitchLines() {
    return this.line;
  }

  private createPivotArpeggioLine(line: Pitch[], lowCut: number, highCut: number) {
    const arpeggioRoot = new PitchLine(line.slice(lowCut, highCut), PitchLineDirection.OctaveDown);
    this.line.add(arpeggioRoot);
    const pivot = new PitchLine(line.slice(highCut), PitchLineDirection.Ascending);
    this.line.add(pivot);
  }

  private lastDegree() {
    const lastPitch = this.line.lastPitch();
    let from: ScaleDegree | undefined = undefined;

    if (lastPitch) from = this.scale.degreeFor(lastPitch);

    return from;
  }
}

1	import { Duration } from './Duration';
2	import { MelodicLine, Octave } from './Note';	2✔
3	import { Pitch, PitchLine, PitchLineDirection } from './Pitch';	2✔
4	import { Scale, ScaleDegree, ScalePattern } from './Scale';	2✔
5
6	export class PitchLines implements Iterable<PitchLine> {	×
7	constructor(private readonly lines: PitchLine[] = []) {}	64✔
8
9	add(line: PitchLine) {
10	this.lines.push(line);	139✔
11	}
12
13	addPitch(pitch: Pitch) {
UNCOV 14	this.lines[this.lines.length - 1]?.push(pitch);	×
15	}
16
17	lastPitch() {
18	const lastLine = this.lines[this.lines.length - 1];	54✔
19
20	if (lastLine) {	54✔
21	return lastLine.lastPitch();	53✔
22	}
23
24	return undefined;	1✔
25	}
26
27	melodicLine(startingOctave: Octave, pitchDurations: Duration) {
28	let octave = startingOctave;	×
29	const melodicLine = new MelodicLine([]);	×
30
31	for (const line of this.lines) {	×
32	octave = melodicLine.lastOctave() ?? startingOctave;	×
33	melodicLine.concat(line.toMelodicLine(octave, pitchDurations));	×
34	}
35
36	return melodicLine;	×
37	}
38
39	flatPitches() {
40	return this.lines.flatMap((l) => [...l]);	×
41	}
42
43	*[Symbol.iterator](): Iterator<PitchLine> {
44	for (const line of this.lines) {	64✔
45	yield line;	139✔
46	}
47	}
48	}
49
50	class BarryHalfStepRule {
51	private constructor(
52	private readonly startDegree: ScaleDegree,	8✔
53	private readonly endDegree: ScaleDegree	8✔
54	) {}
55
56	public static readonly RootAndSeventh = new BarryHalfStepRule(ScaleDegree.I, ScaleDegree.VII);	2✔
57	public static readonly SecondAndRoot = new BarryHalfStepRule(ScaleDegree.II, ScaleDegree.I);	2✔
58	public static readonly ThirdAndSecond = new BarryHalfStepRule(ScaleDegree.III, ScaleDegree.II);	2✔
59	public static readonly SixthAndFifth = new BarryHalfStepRule(ScaleDegree.VI, ScaleDegree.V);	2✔
60
61	apply(line: PitchLine, scale: Scale) {
62	line.insertHalfToneBetween(scale.pitchFor(this.startDegree), scale.pitchFor(this.endDegree));	57✔
63	}
64	}
65
66	class BarryHalfStepRules {
67	private static readonly all: BarryHalfStepRules[] = [];	2✔
68
69	private constructor(
70	private chordTonesMin: BarryHalfStepRule[],	8✔
71	private noChordTonesMin: BarryHalfStepRule[],	8✔
72	private chordTonesMax: BarryHalfStepRule[],	8✔
73	private noChordTonesMax: BarryHalfStepRule[],	8✔
74	private applyesTo: (scale: Scale) => boolean	8✔
75	) {
76	BarryHalfStepRules.all.push(this);	8✔
77	}
78
79	public static readonly Dominant: BarryHalfStepRules = new BarryHalfStepRules(	2✔
80	[BarryHalfStepRule.RootAndSeventh],
81	[],
82	[
83	BarryHalfStepRule.RootAndSeventh,
84	BarryHalfStepRule.SecondAndRoot,
85	BarryHalfStepRule.ThirdAndSecond,
86	],
87	[BarryHalfStepRule.RootAndSeventh, BarryHalfStepRule.SecondAndRoot],
88	(scale: Scale) => scale.hasPattern(ScalePattern.Mixolydian)	39✔
89	);
90
91	public static readonly Major: BarryHalfStepRules = new BarryHalfStepRules(	2✔
92	[BarryHalfStepRule.SixthAndFifth],
93	[],
94	[
95	BarryHalfStepRule.SecondAndRoot,
96	BarryHalfStepRule.ThirdAndSecond,
97	BarryHalfStepRule.SixthAndFifth,
98	],
99	[BarryHalfStepRule.RootAndSeventh, BarryHalfStepRule.SixthAndFifth],
100	(scale: Scale) => scale.hasPattern(ScalePattern.Ionian)	×
101	);
102
103	public static readonly Minor: BarryHalfStepRules = new BarryHalfStepRules(	2✔
104	[BarryHalfStepRule.SixthAndFifth],
105	[],
106	[
107	BarryHalfStepRule.SecondAndRoot,
108	BarryHalfStepRule.ThirdAndSecond,
109	BarryHalfStepRule.SixthAndFifth,
110	],
111	[BarryHalfStepRule.RootAndSeventh, BarryHalfStepRule.SixthAndFifth],
112	(scale: Scale) => scale.hasPattern(ScalePattern.HarmonicMinor)	×
113	);
114
115	public static readonly Default: BarryHalfStepRules = new BarryHalfStepRules(	2✔
116	[],
117	[],
118	[],
119	[],
120	() => false	×
121	);
122
123	static barryRulesFor(scale: Scale) {
124	return (	39✔
125	BarryHalfStepRules.all.find((rule) => rule.applyesTo(scale)) \|\| BarryHalfStepRules.Default	39!
126	);
127	}
128
129	applyMin(scale: Scale, from: ScaleDegree, to: ScaleDegree) {
130	const line = scale.down(from, to);	23✔
131
132	if (this.lineStartsAtChordTone(from)) {	23✔
133	for (const rule of this.chordTonesMin) {	17✔
134	rule.apply(line, scale);	17✔
135	}
136
137	return line;	17✔
138	}
139
140	for (const rule of this.noChordTonesMin) {	6✔
141	rule.apply(line, scale);	×
142	}
143
144	return line;	6✔
145	}
146
147	applyMax(scale: Scale, from: ScaleDegree, to: ScaleDegree) {
148	const line = scale.down(from, to);	16✔
149
150	if (this.lineStartsAtChordTone(from)) {	16✔
151	for (const rule of this.chordTonesMax) {	8✔
152	rule.apply(line, scale);	24✔
153	}
154
155	return line;	8✔
156	}
157
158	for (const rule of this.noChordTonesMax) {	8✔
159	rule.apply(line, scale);	16✔
160	}
161
162	return line;	8✔
163	}
164
165	private lineStartsAtChordTone(degree: ScaleDegree) {
166	return !!(	39✔
167	degree === ScaleDegree.I \|\|	113✔
168	degree === ScaleDegree.III \|\|
169	degree === ScaleDegree.V \|\|
170	degree === ScaleDegree.VII
171	);
172	}
173	}
174
175	export class BarryHarrisLine {	64✔
176	private readonly line: PitchLines;
177
178	constructor(private readonly scale: Scale) {	64✔
179	this.line = new PitchLines();	64✔
180	}
181
182	arpeggioUpFrom(degree: ScaleDegree) {
183	const arpeggio = new PitchLine(	31✔
184	this.scale.thirdsFrom(degree).slice(0, 4),
185	PitchLineDirection.Ascending
186	);
187
188	this.line.add(arpeggio);	31✔
189
190	return this;	31✔
191	}
192
193	arpeggioUpFromLastPitch() {
194	const from = this.lastDegree();	9✔
195
196	if (from) {	9✔
197	const arpeggio = new PitchLine(	8✔
198	this.scale.thirdsFrom(from).slice(1, 4),
199	PitchLineDirection.Ascending
200	);
201
202	this.line.add(arpeggio);	8✔
203	}
204
205	return this;	9✔
206	}
207
208	pivotArpeggioUpFrom(degree: ScaleDegree) {
209	const arpeggio = this.scale.thirdsTo(degree).slice(0, 4);	9✔
210	this.createPivotArpeggioLine(arpeggio, 0, 1);	9✔
211	return this;	9✔
212	}
213
214	pivotArpeggioUpFromLastPitch() {
215	const from = this.lastDegree();	10✔
216
217	if (from) {	10✔
218	const arpeggio = this.scale.thirdsTo(from).slice(0, 4);	10✔
219	this.createPivotArpeggioLine(arpeggio, 1, 2);	10✔
220	}
221
222	return this;	10✔
223	}
224
225	resolveTo(pitch: Pitch) {
226	this.line.add(	23✔
227	new PitchLine(
228	[pitch],
229	this.line.lastPitch()! > pitch	23!
230	? PitchLineDirection.Descending
231	: PitchLineDirection.Ascending
232	)
233	);
234	return this;	23✔
235	}
236
237	scaleDown(to: ScaleDegree, from: ScaleDegree) {
238	this.line.add(BarryHalfStepRules.barryRulesFor(this.scale).applyMin(this.scale, from, to));	23✔
239
240	return this;	23✔
241	}
242
243	scaleDownExtraHalfSteps(to: ScaleDegree, from: ScaleDegree) {
244	this.line.add(BarryHalfStepRules.barryRulesFor(this.scale).applyMax(this.scale, from, to));	16✔
245
246	return this;	16✔
247	}
248
249	scaleDownFromLastPitchTo(to: ScaleDegree) {
250	const from = this.lastDegree();	10✔
251
252	if (from) {	10✔
253	this.scaleDown(to, from - 1);	10✔
254	}
255
256	return this;	10✔
257	}
258
259	scaleDownExtraHalfStepsFromLastPitch(to: ScaleDegree) {
260	const from = this.lastDegree();	2✔
261
262	if (from) {	2✔
263	this.scaleDownExtraHalfSteps(to, from - 1);	2✔
264	}
265
266	return this;	2✔
267	}
268
269	build(startingOctave: Octave, pitchDurations: Duration) {
270	let octave = startingOctave;	43✔
271	const melodicLine = new MelodicLine([]);	43✔
272
273	for (const line of this.line) {	43✔
274	octave = melodicLine.lastOctave() ?? startingOctave;	68✔
275	melodicLine.concat(line.toMelodicLine(octave, pitchDurations));	68✔
276	}
277
278	return melodicLine;	43✔
279	}
280
281	buildPitchLines() {
282	return this.line;	21✔
283	}
284
285	private createPivotArpeggioLine(line: Pitch[], lowCut: number, highCut: number) {
286	const arpeggioRoot = new PitchLine(line.slice(lowCut, highCut), PitchLineDirection.OctaveDown);	19✔
287	this.line.add(arpeggioRoot);	19✔
288	const pivot = new PitchLine(line.slice(highCut), PitchLineDirection.Ascending);	19✔
289	this.line.add(pivot);	19✔
290	}
291
292	private lastDegree() {
293	const lastPitch = this.line.lastPitch();	31✔
294	let from: ScaleDegree \| undefined = undefined;	31✔
295
296	if (lastPitch) from = this.scale.degreeFor(lastPitch);	31✔
297
298	return from;	31✔
299	}
300	}

pedromsantos / glenn / 9701182518

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous