7817088272

Committed 07 Feb 2024 03:22PM UTC coverage: 79.153% (-1.8%) from 80.966%

Build # 7817088272

Build Type

Pull #187

github

Committed by

web-flow

Commit Message

Merge ddbc8b367 into fa60a2e90

Pull Request Pull Request #187: Removing old `fast-xml-parser` in favor of `@rgrove/parse-xml`

Run Details

872 of 1147 branches covered (0.0%)

Branch coverage included in aggregate %.

94 of 106 new or added lines in 15 files covered. (88.68%)

25 existing lines in 2 files now uncovered.

1706 of 2110 relevant lines covered (80.85%)

77.9 hits per line

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

83.57

/src/helpers/xml-helper.ts

import {
  XmlCdata,
  XmlComment,
  XmlDeclaration,
  XmlDocument, XmlDocumentType, XmlElement, XmlProcessingInstruction, XmlText, parseXml,
} from '@rgrove/parse-xml';
import { encode, decode } from 'html-entities';

export default class XmlHelper {
  /**
   * Decode an encoded xml string
   *
   * @static
   * @param {string} text Encoded XML
   * @returns {string} Decoded XML
   * @memberof XmlHelper
   */
  static DecodeXml(text: unknown): string | undefined {
    if (typeof text !== 'string' || text === '') {
      return undefined;
    }
    if (typeof text === 'string' && !text.startsWith('$lt;')) {
      return text;
    }

    return decode(text, { level: 'xml' });
  }

  /**
   * Decode an encoded xml string
   *
   * @static
   * @param {string} text Encoded XML
   * @returns {string} Decoded XML
   * @memberof XmlHelper
   */
  static DecodeHtml(text: unknown): string | undefined {
    if (typeof text === 'undefined' || (typeof text === 'string' && text === '')) {
      return undefined;
    }
    if (typeof text !== 'string') {
      return XmlHelper.DecodeHtml(`${text}`);
    }
    return decode(text);
  }

  /**
   * DecodeAndParseXml will decode the encoded xml string and then try to parse it
   *
   * @static
   * @param {string} encodedXml Encoded Xml string
   * @returns {*} a parsed Object of the XML string
   * @memberof XmlHelper
   */
  static DecodeAndParseXml(encodedXml: unknown): Record<string, unknown> | unknown {
    const decoded = XmlHelper.DecodeXml(encodedXml);
    if (typeof decoded === 'undefined') return undefined;
    return this.ParseXml(decoded, false);
  }

  /**
   * DecodeAndParseXml will decode the encoded xml string and then try to parse it
   *
   * @static
   * @param {string} encodedXml Encoded Xml string
   * @returns {*} a parsed Object of the XML string
   * @memberof XmlHelper
   */
  static DecodeAndParseXmlNoNS(encodedXml: unknown): Record<string, unknown> | unknown {
    const decoded = XmlHelper.DecodeXml(encodedXml);
    return decoded ? this.ParseXml(decoded, true) : undefined;
  }

  static ParseEmbeddedXml(input: unknown): Record<string, unknown> | unknown {
    if (typeof input !== 'string' || input === '') return undefined;
    const inputToParse = input.indexOf('\\"') > -1 ? input.replace('\\"', '"') : input;

    const xmlDocument = parseXml(inputToParse as string);

    const result = this.NormalizeXml(xmlDocument, true);
    return result;
  }

  static ParseXml(input: unknown, removeNamespace = false): Record<string, unknown> | unknown {
    if (typeof input !== 'string' || input === '') return undefined;
    const xmlDocument = parseXml(input);

    const result = this.NormalizeXml(xmlDocument, removeNamespace);
    return result;
  }

  private static ParseValue(input: unknown): unknown {
    if (typeof input === 'string') {
      if (input === 'true') return true;
      if (input === 'false') return false;
      if (input === 'null') return null;
      // check if the supplied input value might be a string representation of a number
      if (!Number.isNaN(Number(input))) return Number(input);
      return input;
    }
    return input;
  }

  static NormalizeXml(input: XmlDocument | XmlElement | unknown, removeNamespace: boolean): Record<string, unknown> | unknown {
    if (input === null) return undefined;
    if (input instanceof XmlText) {
      return input.text;
    }

    if ((input instanceof XmlDocument) || (input instanceof XmlElement)) {
      if (input.children.length === 1 && input.children[0] instanceof XmlText && (input instanceof XmlElement && Object.keys(input.attributes).length === 0)) {
        return this.ParseValue(input.children[0].text);
      }
      const result: Record<string, unknown> = {};

      if (input instanceof XmlElement) {
        // itereate over the attributes and add them to the result
        // tell eslint to ignore the next line as it is a for of loop
        // eslint-disable-next-line no-restricted-syntax
        for (const [key, value] of Object.entries(input.attributes)) {
          if (!key.startsWith('xmlns')) {
            const finalKey = removeNamespace ? key.replace(/.*:/, '') : key;
            result[finalKey] = this.ParseValue(value);
          }
        }
      }

      input.children.forEach((child: XmlElement | XmlText | XmlCdata | XmlComment | XmlProcessingInstruction | XmlDeclaration | XmlDocumentType) => {
      // for (const child of input.children) {
        if (child instanceof XmlElement) {
          const value = this.NormalizeXml(child, removeNamespace);
          const name = removeNamespace ? child.name.replace(/.*:/, '') : child.name;
          if (name in result) {
            const existing = result[name];
            if (Array.isArray(existing)) {
              existing.push(value);
            } else {
              result[name] = [existing, value];
            }
          } else {
            result[name] = value;
          }
        } else if (child instanceof XmlText) {
          if (child.text.trim() !== '') {
            result['#text'] = this.ParseValue(child.text);
          }
        }
      // }
      });
      return result;
    }
    if (input instanceof XmlText) {
      return this.ParseValue(input.text);
    }
    return input;
  }

  /**
   * EncodeXml will encode a xml string so it is safe to send to sonos.
   *
   * @static
   * @param {string} xml
   * @returns {string}
   * @memberof XmlHelper
   */
  static EncodeXml(xml: unknown): string {
    if (typeof xml !== 'string' || xml === '') return '';
    return encode(xml, { level: 'xml' });
  }

  static EncodeTrackUri(trackUri: string): string {
    if (trackUri.startsWith('http')) return encodeURI(trackUri);
    if (
      trackUri.startsWith('x-sonos-hta')
      || trackUri.startsWith('x-rincon-mp3radio')
    ) return trackUri;

    if (trackUri.startsWith('x-rincon-playlist:')) {
      const index = trackUri.indexOf('/');
      return trackUri.substr(0, index) + this.EncodeXml(trackUri.substr(index)).replace(/:/g, '%3a').replace(/ /g, '%20');
    }

    // Part below needs some work.
    const index = trackUri.indexOf(':') + 1;
    return trackUri.substr(0, index) + this.EncodeXml(trackUri.substr(index)).replace(/:/g, '%3a');
  }

  static DecodeTrackUri(input: unknown): string | undefined {
    if (typeof input !== 'string' || input === '') {
      return undefined;
    }
    return XmlHelper.DecodeXml(decodeURIComponent(input));
  }
}

1	import {	20✔
2	XmlCdata,
3	XmlComment,
4	XmlDeclaration,
5	XmlDocument, XmlDocumentType, XmlElement, XmlProcessingInstruction, XmlText, parseXml,
6	} from '@rgrove/parse-xml';
7	import { encode, decode } from 'html-entities';	20✔
8
9	export default class XmlHelper {	20✔
10	/**
11	* Decode an encoded xml string
12	*
13	* @static
14	* @param {string} text Encoded XML
15	* @returns {string} Decoded XML
16	* @memberof XmlHelper
17	*/
18	static DecodeXml(text: unknown): string \| undefined {
19	if (typeof text !== 'string' \|\| text === '') {	210✔
20	return undefined;	4✔
21	}
22	if (typeof text === 'string' && !text.startsWith('$lt;')) {	206✔
23	return text;	206✔
24	}
25
UNCOV 26	return decode(text, { level: 'xml' });	×
27	}
28
29	/**
30	* Decode an encoded xml string
31	*
32	* @static
33	* @param {string} text Encoded XML
34	* @returns {string} Decoded XML
35	* @memberof XmlHelper
36	*/
37	static DecodeHtml(text: unknown): string \| undefined {
38	if (typeof text === 'undefined' \|\| (typeof text === 'string' && text === '')) {	448✔
39	return undefined;	106✔
40	}
41	if (typeof text !== 'string') {	342✔
42	return XmlHelper.DecodeHtml(`${text}`);	2✔
43	}
44	return decode(text);	340✔
45	}
46
47	/**
48	* DecodeAndParseXml will decode the encoded xml string and then try to parse it
49	*
50	* @static
51	* @param {string} encodedXml Encoded Xml string
52	* @returns {*} a parsed Object of the XML string
53	* @memberof XmlHelper
54	*/
55	static DecodeAndParseXml(encodedXml: unknown): Record<string, unknown> \| unknown {
56	const decoded = XmlHelper.DecodeXml(encodedXml);	64✔
57	if (typeof decoded === 'undefined') return undefined;	64✔
58	return this.ParseXml(decoded, false);	62✔
59	}
60
61	/**
62	* DecodeAndParseXml will decode the encoded xml string and then try to parse it
63	*
64	* @static
65	* @param {string} encodedXml Encoded Xml string
66	* @returns {*} a parsed Object of the XML string
67	* @memberof XmlHelper
68	*/
69	static DecodeAndParseXmlNoNS(encodedXml: unknown): Record<string, unknown> \| unknown {
70	const decoded = XmlHelper.DecodeXml(encodedXml);	2✔
71	return decoded ? this.ParseXml(decoded, true) : undefined;	2!
72	}
73
74	static ParseEmbeddedXml(input: unknown): Record<string, unknown> \| unknown {
NEW 75	if (typeof input !== 'string' \|\| input === '') return undefined;	×
NEW 76	const inputToParse = input.indexOf('\\"') > -1 ? input.replace('\\"', '"') : input;	×
77
NEW 78	const xmlDocument = parseXml(inputToParse as string);	×
79
NEW 80	const result = this.NormalizeXml(xmlDocument, true);	×
NEW 81	return result;	×
82	}
83
84	static ParseXml(input: unknown, removeNamespace = false): Record<string, unknown> \| unknown {	176✔
85	if (typeof input !== 'string' \|\| input === '') return undefined;	262!
86	const xmlDocument = parseXml(input);	262✔
87
88	const result = this.NormalizeXml(xmlDocument, removeNamespace);	262✔
89	return result;	262✔
90	}
91
92	private static ParseValue(input: unknown): unknown {
93	if (typeof input === 'string') {	7,882✔
94	if (input === 'true') return true;	7,882✔
95	if (input === 'false') return false;	7,759✔
96	if (input === 'null') return null;	7,741!
97	// check if the supplied input value might be a string representation of a number
98	if (!Number.isNaN(Number(input))) return Number(input);	7,741✔
99	return input;	4,641✔
100	}
NEW 101	return input;	×
102	}
103
104	static NormalizeXml(input: XmlDocument \| XmlElement \| unknown, removeNamespace: boolean): Record<string, unknown> \| unknown {
105	if (input === null) return undefined;	4,456!
106	if (input instanceof XmlText) {	4,456!
NEW 107	return input.text;	×
108	}
109
110	if ((input instanceof XmlDocument) \|\| (input instanceof XmlElement)) {	4,456✔
111	if (input.children.length === 1 && input.children[0] instanceof XmlText && (input instanceof XmlElement && Object.keys(input.attributes).length === 0)) {	4,456✔
112	return this.ParseValue(input.children[0].text);	1,193✔
113	}
114	const result: Record<string, unknown> = {};	3,263✔
115
116	if (input instanceof XmlElement) {	3,263✔
117	// itereate over the attributes and add them to the result
118	// tell eslint to ignore the next line as it is a for of loop
119	// eslint-disable-next-line no-restricted-syntax
120	for (const [key, value] of Object.entries(input.attributes)) {	3,001✔
121	if (!key.startsWith('xmlns')) {	7,078✔
122	const finalKey = removeNamespace ? key.replace(/.*:/, '') : key;	6,547!
123	result[finalKey] = this.ParseValue(value);	6,547✔
124	}
125	}
126	}
127
128	input.children.forEach((child: XmlElement \| XmlText \| XmlCdata \| XmlComment \| XmlProcessingInstruction \| XmlDeclaration \| XmlDocumentType) => {	3,263✔
129	// for (const child of input.children) {
130	if (child instanceof XmlElement) {	4,921✔
131	const value = this.NormalizeXml(child, removeNamespace);	4,194✔
132	const name = removeNamespace ? child.name.replace(/.*:/, '') : child.name;	4,194✔
133	if (name in result) {	4,194✔
134	const existing = result[name];	534✔
135	if (Array.isArray(existing)) {	534✔
136	existing.push(value);	492✔
137	} else {
138	result[name] = [existing, value];	42✔
139	}
140	} else {
141	result[name] = value;	3,660✔
142	}
143	} else if (child instanceof XmlText) {	727✔
144	if (child.text.trim() !== '') {	727✔
145	result['#text'] = this.ParseValue(child.text);	142✔
146	}
147	}
148	// }
149	});
150	return result;	3,263✔
151	}
NEW 152	if (input instanceof XmlText) {	×
NEW 153	return this.ParseValue(input.text);	×
154	}
NEW 155	return input;	×
156	}
157
158	/**
159	* EncodeXml will encode a xml string so it is safe to send to sonos.
160	*
161	* @static
162	* @param {string} xml
163	* @returns {string}
164	* @memberof XmlHelper
165	*/
166	static EncodeXml(xml: unknown): string {
167	if (typeof xml !== 'string' \|\| xml === '') return '';	46✔
168	return encode(xml, { level: 'xml' });	44✔
169	}
170
171	static EncodeTrackUri(trackUri: string): string {
172	if (trackUri.startsWith('http')) return encodeURI(trackUri);	28✔
173	if (	26✔
174	trackUri.startsWith('x-sonos-hta')	51✔
175	\|\| trackUri.startsWith('x-rincon-mp3radio')
176	) return trackUri;	2✔
177
178	if (trackUri.startsWith('x-rincon-playlist:')) {	24✔
179	const index = trackUri.indexOf('/');	2✔
180	return trackUri.substr(0, index) + this.EncodeXml(trackUri.substr(index)).replace(/:/g, '%3a').replace(/ /g, '%20');	2✔
181	}
182
183	// Part below needs some work.
184	const index = trackUri.indexOf(':') + 1;	22✔
185	return trackUri.substr(0, index) + this.EncodeXml(trackUri.substr(index)).replace(/:/g, '%3a');	22✔
186	}
187
188	static DecodeTrackUri(input: unknown): string \| undefined {
189	if (typeof input !== 'string' \|\| input === '') {	147✔
190	return undefined;	3✔
191	}
192	return XmlHelper.DecodeXml(decodeURIComponent(input));	144✔
193	}
194	}

svrooij / node-sonos-ts / 7817088272

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