Test directive selector

See https://www.chordpro.org/chordpro/chordpro-directives/#conditional-directives

Related to #983

src/formatter/configuration/configuration.ts

@@ -6,6 +6,9 @@ import MetadataConfiguration, {
   MetadataConfigurationProperties,
 } from './metadata_configuration';
 
+import InstrumentConfiguration, { InstrumentConfigurationProperties } from './instrument_configuration';
+import UserConfiguration, { UserConfigurationProperties } from './user_configuration';
+
 export type Delegate = (_string: string) => string;
 export const defaultDelegate: Delegate = (string: string) => string;
 
@@ -17,6 +20,8 @@ export type ConfigurationProperties = Record<string, any> & {
   useUnicodeModifiers: boolean,
   normalizeChords: boolean,
   delegates: Partial<Record<ContentType, Delegate>>;
+  instrument?: InstrumentConfigurationProperties;
+  user?: UserConfigurationProperties;
 };
 
 export const defaultConfiguration: ConfigurationProperties = {
@@ -41,8 +46,6 @@ class Configuration {
 
   key: Key | null;
 
-  configuration: Record<string, any>;
-
   expandChorusDirective: boolean;
 
   useUnicodeModifiers: boolean;
@@ -51,6 +54,10 @@ class Configuration {
 
   delegates: Partial<Record<ContentType, Delegate>>;
 
+  instrument?: InstrumentConfiguration;
+
+  user?: UserConfiguration;
+
   get metadataSeparator(): string {
     return this.metadata.separator ?? '';
   }
@@ -64,7 +71,8 @@ class Configuration {
     this.metadata = new MetadataConfiguration(configuration.metadata);
     this.key = configuration.key ? Key.wrap(configuration.key) : null;
     this.delegates = { ...defaultConfiguration.delegates, ...configuration.delegates };
-    this.configuration = { configuration, delegates: this.delegates };
+    this.instrument = configuration.instrument ? new InstrumentConfiguration(configuration.instrument) : undefined;
+    this.user = configuration.user ? new UserConfiguration(configuration.user) : undefined;
   }
 }
 

src/formatter/configuration/instrument_configuration.ts

@@ -0,0 +1,17 @@
+export interface InstrumentConfigurationProperties {
+  type?: string;
+  description?: string;
+}
+
+class InstrumentConfiguration {
+  type?: string;
+
+  description?: string;
+
+  constructor(instrumentConfiguration: Partial<InstrumentConfigurationProperties> = {}) {
+    this.type = instrumentConfiguration.type;
+    this.description = instrumentConfiguration.description;
+  }
+}
+
+export default InstrumentConfiguration;

src/formatter/configuration/metadata_configuration.ts

@@ -9,8 +9,8 @@ export const defaultMetadataConfiguration: MetadataConfigurationProperties = {
 class MetadataConfiguration {
   separator?: string;
 
-  constructor(metadataConfiguration: MetadataConfigurationProperties = defaultMetadataConfiguration) {
-    this.separator = metadataConfiguration.separator;
+  constructor(metadataConfiguration: Partial<MetadataConfigurationProperties> = {}) {
+    this.separator = metadataConfiguration.separator || defaultMetadataConfiguration.separator;
   }
 }
 

src/formatter/configuration/user_configuration.ts

@@ -0,0 +1,17 @@
+export interface UserConfigurationProperties {
+  name?: string;
+  fullname?: string;
+}
+
+class UserConfiguration {
+  name?: string;
+
+  fullname?: string;
+
+  constructor(userConfiguration: Partial<UserConfigurationProperties> = {}) {
+    this.name = userConfiguration.name;
+    this.fullname = userConfiguration.fullname;
+  }
+}
+
+export default UserConfiguration;

src/helpers.ts

@@ -4,6 +4,8 @@ import { capos, majorKeys, minorKeys } from './key_config';
 import Song from './chord_sheet/song';
 import { CAPO, CHORD_STYLE, ChordType } from './chord_sheet/tag';
 import Line from './chord_sheet/line';
+import Configuration from './formatter/configuration/configuration';
+import Metadata from './chord_sheet/metadata';
 
 export function transposeDistance(transposeKey: string, songKey: string): number {
   if (/^\d+$/.test(transposeKey)) {
@@ -109,3 +111,17 @@ export function getKeys(key: Key | string): string[] {
   const chordType = keyObj.type === 'solfege' ? 'solfege' : 'symbol';
   return keyObj.isMinor() ? minorKeys[chordType] : majorKeys[chordType];
 }
+
+export function testSelector(selector: string, configuration: Configuration, metadata: Metadata) {
+  if (selector === configuration.instrument?.type) {
+    return true;
+  }
+
+  if (selector === configuration.user?.name) {
+    return true;
+  }
+
+  const metadataValue = metadata.getSingle(selector);
+
+  return !!(metadataValue && metadataValue !== '');
+}

test/helpers.test.ts

@@ -1,7 +1,9 @@
 import Song from '../src/chord_sheet/song';
 import { createLine } from './utilities';
-import { renderChord } from '../src/helpers';
+import { renderChord, testSelector } from '../src/helpers';
 import Key from '../src/key';
+import Metadata from '../src/chord_sheet/metadata';
+import Configuration from '../src/formatter/configuration/configuration';
 
 describe('renderChord', () => {
   it('correctly normalizes when a capo is set', () => {
@@ -29,3 +31,54 @@ describe('renderChord', () => {
     expect(renderChord('Dm7', line, song, { renderKey: Key.parse('B'), useUnicodeModifier: true })).toEqual('G♯m7');
   });
 });
+
+describe('testSelector', () => {
+  it('returns true when the selector matches the configured instrument type', () => {
+    const configuration = new Configuration({ instrument: { type: 'guitar' } });
+    const metadata = new Metadata();
+
+    expect(testSelector('guitar', configuration, metadata)).toEqual(true);
+  });
+
+  it('returns false when the selector does not match the configured instrument type', () => {
+    const configuration = new Configuration({ instrument: { type: 'guitar' } });
+    const metadata = new Metadata();
+
+    expect(testSelector('piano', configuration, metadata)).toEqual(false);
+  });
+
+  it('return true when the selector matches the configured user name', () => {
+    const configuration = new Configuration({ user: { name: 'john' } });
+    const metadata = new Metadata();
+
+    expect(testSelector('john', configuration, metadata)).toEqual(true);
+  });
+
+  it('returns false when the selector does not match the configured user name', () => {
+    const configuration = new Configuration({ user: { name: 'john' } });
+    const metadata = new Metadata();
+
+    expect(testSelector('jane', configuration, metadata)).toEqual(false);
+  });
+
+  it('returns true when the selector matches a truthy metadata value', () => {
+    const configuration = new Configuration();
+    const metadata = new Metadata({ 'horns': 'true' });
+
+    expect(testSelector('horns', configuration, metadata)).toEqual(true);
+  });
+
+  it('returns false when the selector matches an empty metadata value', () => {
+    const configuration = new Configuration();
+    const metadata = new Metadata({ 'horns': '' });
+
+    expect(testSelector('horns', configuration, metadata)).toEqual(false);
+  });
+
+  it('returns false when the selector does not match a metadata value', () => {
+    const configuration = new Configuration();
+    const metadata = new Metadata();
+
+    expect(testSelector('horns', configuration, metadata)).toEqual(false);
+  });
+});