2956299703

Build Type

github

Committed by GitHub

Commit Message

Merge aef0927d3 into 360a451a3

Pull Request Pull Request #6: Correctly detect invalid members of enums when MemberGroupSeparator is used

Run Details

2338 of 2470 branches covered (94.66%)

Branch coverage included in aggregate %.

81 of 81 new or added lines in 4 files covered. (100.0%)

13 existing lines in 1 file now uncovered.

4543 of 4602 relevant lines covered (98.72%)

2737.12 hits per line

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

91.34

/parsers/MSONNamedTypeParser.js

const SectionTypes = require('../SectionTypes');
const { types } = require('../constants');
const utils = require('../utils');
const { parser: SignatureParser, traits: ParserTraits } = require('../SignatureParser');
const MSONNamedTypeElement = require('./elements/MSONNamedTypeElement');
const ValueMemberElement = require('./elements/ValueMemberElement');
const EnumElement = require('./elements/EnumElement');
const ObjectElement = require('./elements/ObjectElement');
const SchemaNamedTypeElement = require('./elements/SchemaNamedTypeElement');
const UnrecognizedBlockElement = require('./elements/UnrecognizedBlockElement');
const DataStructureProcessor = require('../DataStructureProcessor');
const ValueMemberProcessor = require('../ValueMemberProcessor');

const { CrafterError } = utils;

module.exports = (Parsers) => {
  Parsers.MSONNamedTypeParser = Object.assign(Object.create(require('./AbstractParser')), {
    processSignature(node, context) {
      context.pushFrame();

      const [subject, subjectOffset] = utils.headerTextWithOffset(node, context.sourceLines);
      const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
      let signature;
      try {
        signature = new SignatureParser(subject, context.languageServerMode, [ParserTraits.NAME, ParserTraits.ATTRIBUTES]);
      } catch (e) {
        if (!(e instanceof utils.SignatureError)) {
          throw e;
        } else {
          const hashSymbols = Array(node.level).fill('#').join('');
          const message = `Invalid NamedType definition. Expected format: "${hashSymbols} Type Name (Type Attributes)".`;
          throw new CrafterError(message, sourceMap);
        }
      }
      signature.warnings.forEach(warning => context.addWarning(warning, sourceMap));

      context.data.attributeSignatureDetails = { sourceMap, node };

      const resolvedType = utils.resolveType(signature.type);
      const nestedTypes = resolvedType.nestedTypes.map((nestedType, index) => {
        const el = new ValueMemberElement(nestedType, nestedType, []);
        el.sourceMap = utils.makeSourceMapsForString(
          nestedType,
          resolvedType.nestedTypesOffsets[index] + signature.typeOffset + subjectOffset,
          node,
          context.sourceLines,
          context.sourceBuffer,
          context.linefeedOffsets,
          context.filename,
        );
        return el;
      });
      const valueElement = new ValueMemberElement(
        signature.type,
        resolvedType.type,
        nestedTypes,
        signature.typeAttributes,
      );

      const valueMemberSourceMaps = [];

      signature.typeAttributes.forEach((attr, index) => {
        const [offset, length] = signature.typeAttributesOffsetsAndLengths[index];

        valueMemberSourceMaps.push(utils.makeSourceMapsForStartPosAndLength(
          offset + subjectOffset,
          length,
          node,
          context.sourceLines,
          context.sourceBuffer,
          context.linefeedOffsets,
          context.filename,
        ));
      });

      if (signature.type) {
        valueMemberSourceMaps.push(utils.makeSourceMapsForString(
          signature.type,
          signature.typeOffset + subjectOffset,
          node,
          context.sourceLines,
          context.sourceBuffer,
          context.linefeedOffsets,
          context.filename,
        ));
      }

      valueMemberSourceMaps.sort((sm1, sm2) => sm1.byteBlocks[0].offset - sm2.byteBlocks[0].offset);

      if (valueMemberSourceMaps.length) {
        valueElement.sourceMap = utils.concatSourceMaps(valueMemberSourceMaps);
      }

      const name = utils.makeStringElement(signature.name, signature.nameOffset + subjectOffset, node, context);
      const typeElement = new MSONNamedTypeElement(name, valueElement, sourceMap);

      if (!context.typeExtractingInProgress) {
        const typeEl = context.typeResolver.types[signature.type];
        if (typeEl && typeEl instanceof SchemaNamedTypeElement && !context.languageServerMode) {
          throw new CrafterError('No inheritance allowed from schema named type.', sourceMap);
        }

        try {
          ValueMemberProcessor.fillBaseType(context, typeElement.content);
        } catch (error) {
          if (!error.sourceMap) {
            error.sourceMap = typeElement.name.sourceMap;
          }
          throw error;
        }
      }

      return [utils.nextNode(node), typeElement];
    },

    sectionType(node, context) {
      if (node.type === 'heading' && context.sectionKeywordSignature(node) === SectionTypes.undefined) {
        return SectionTypes.MSONNamedType;
      }

      return SectionTypes.undefined;
    },

    processNestedSections(node, context, result) {
      let curNode = node;
      const valueMemberDefaults = [];

      while (curNode) {
        if (curNode.type === 'item') {
          if (!context.typeExtractingInProgress) {
            const dataStructureProcessor = new DataStructureProcessor(curNode.parent, Parsers, undefined, curNode.parent);
            const isFixedOrFixedType = result.content.typeAttributes.includes('fixed') || result.content.typeAttributes.includes('fixedType');
            const isFixedOrFixedTypePropagated = result.content.propagatedTypeAttributes
              && (result.content.propagatedTypeAttributes.includes('fixed') || result.content.propagatedTypeAttributes.includes('fixedType'));
            context.data.isParentAttributeFixedOrFixedType = context.data.isParentAttributeFixedOrFixedType || isFixedOrFixedType || isFixedOrFixedTypePropagated;
            context.data.isNamedTypeSection = true;
            dataStructureProcessor.fillValueMember(result.content, context);
            delete context.data.isParentAttributeFixedOrFixedType;
            delete context.data.isNamedTypeSection;
          }

          curNode = utils.nextNode(curNode.parent);
        } else if (Parsers.NamedTypeMemberGroupParser.sectionType(curNode, context) !== SectionTypes.undefined) {
          if (!context.typeExtractingInProgress) {
            let type = result.content.type || types.object;

            if (context.typeResolver.types[type]) {
              type = context.typeResolver.getStandardBaseType(type);
            }
            context.data.isNamedTypeSection = true;
            context.data.parentType = type;
            context.data.parentNestedTypes = result.content.nestedTypes;

            const [nextNode, memberGroup] = Parsers.NamedTypeMemberGroupParser.parse(curNode, context);

            delete context.data.parentType;
            delete context.data.parentNestedTypes;
            delete context.data.isNamedTypeSection;

            if (memberGroup.childValueMember) {
              const { childValueMember } = memberGroup;
              const rootValueMember = result.content;
              const membersField = type === types.object ? 'propertyMembers' : 'members';
              const contentMembers = childValueMember.content[membersField];

              if (!rootValueMember.content) {
                rootValueMember.content = childValueMember.content;
              } else {
                rootValueMember.content[membersField].push(...contentMembers);
              }

              if (childValueMember.unrecognizedBlocks.length > 0) {
                appendUnrecognizedBlocks(childValueMember.unrecognizedBlocks.map(ub => ub.sourceMap));
              }

              const contentMembersSourceMaps = contentMembers.map(cm => cm.sourceMap);
              if (rootValueMember.sourceMap) {
                rootValueMember.sourceMap = utils.concatSourceMaps([rootValueMember.sourceMap, ...contentMembersSourceMaps]);
              } else {
                rootValueMember.sourceMap = utils.concatSourceMaps(contentMembersSourceMaps);
              }
            }

            const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
            if (result.content.sourceMap) {
              result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sourceMap]);
            } else {
              result.content.sourceMap = sourceMap;
            }

            curNode = nextNode;
          } else {
            curNode = utils.nextNodeOfType(curNode, 'heading');
          }
        } else if (Parsers.SampleHeaderParser.sectionType(curNode, context) !== SectionTypes.undefined) {
          let unrecognizedBlockDetected = false;

          if (!context.typeExtractingInProgress) {
            const valueMember = result.content;

            if (!valueMember.isComplex()) {
              context.data.typeForSamples = 'primitive';
              context.data.valueType = valueMember.type;
              const [, childResult] = Parsers.SampleHeaderParser.parse(curNode, context);
              delete context.data.typeForSamples;
              delete context.data.valueType;

              if (childResult.length) {
                valueMember.samples = valueMember.samples || [];
                valueMember.samples.push(...childResult);

                const childSourceMaps = [];
                childResult.forEach(child => childSourceMaps.push(child.sourceMap));
                concatSourceMaps(valueMember, childSourceMaps);
              }
            }

            if (valueMember.isObject()) {
              const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
              throw new utils.CrafterError('Sample is not supported for objects', sourceMap);
            }

            if (valueMember.isArray()) {
              const arrayElement = valueMember.content;
              const arrayMembers = arrayElement.members;
              const predefinedType = (arrayMembers.length && arrayMembers[0].type) || 'string';
              const hasComplexMembers = arrayElement.isComplex();

              if (!hasComplexMembers) {
                context.data.typeForSamples = 'array';
                context.data.valueType = predefinedType;
                const [, childResult] = Parsers.SampleHeaderParser.parse(curNode, context);
                delete context.data.typeForSamples;
                delete context.data.valueType;

                if (childResult.length) {
                  valueMember.samples = valueMember.samples || [];
                  valueMember.samples.push(...childResult);

                  const childSourceMaps = [];
                  childResult.forEach(child => {
                    childSourceMaps.push(...child.sourceMap);
                  });
                  concatSourceMaps(valueMember, childSourceMaps);
                }
              } else {
                unrecognizedBlockDetected = true;
                const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
                context.addWarning('Samples of arrays of non-primitive types are not supported', sourceMap);
              }
            }

            if (valueMember.isEnum()) {
              const enumElement = valueMember.content;
              const hasComplexMembers = enumElement.isComplex();

              if (!hasComplexMembers) {
                context.data.typeForSamples = 'enum';
                context.data.valueType = enumElement.type;
                const [, childResult] = Parsers.SampleHeaderParser.parse(curNode, context);
                delete context.data.typeForSamples;
                delete context.data.valueType;
                if (childResult.length) {
                  enumElement.sampleValues = childResult;

                  const childSourceMaps = childResult.map(child => child.sourceMap);
                  concatSourceMaps(valueMember, childSourceMaps);
                }
              } else {
                unrecognizedBlockDetected = true;
                const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
                context.addWarning('Samples of enum of non-primitive types are not supported', sourceMap);
              }
            }

            const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
            if (result.content.sourceMap) {
              result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sourceMap]);
            } else {
              result.content.sourceMap = sourceMap;
            }
          }

          let lastNodeOfSection = curNode;
          let nextNode = curNode;
          do {
            lastNodeOfSection = nextNode;
            nextNode = utils.nextNode(nextNode);
          } while (nextNode && nextNode.type !== 'heading');

          if (unrecognizedBlockDetected) {
            const sourceMap = utils.makeGenericSourceMapFromStartAndEndNodes(
              curNode,
              lastNodeOfSection,
              context.sourceLines,
              context.sourceBuffer,
              context.linefeedOffsets,
              context.filename,
            );
            appendUnrecognizedBlocks([sourceMap]);
          }

          curNode = nextNode;
        } else if (Parsers.DefaultHeaderParser.sectionType(curNode, context) !== SectionTypes.undefined) {
          let unrecognizedBlockDetected = false;

          if (!context.typeExtractingInProgress) {
            const valueMember = result.content;

            if (!valueMember.isComplex()) {
              assignValueMemberDefault(valueMember, 'primitive', valueMember.type, valueMemberDefaults);
            }

            if (valueMember.isObject()) {
              const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
              throw new utils.CrafterError('Default is not supported for objects', sourceMap);
            }

            if (valueMember.isArray()) {
              const arrayElement = valueMember.content;
              const arrayMembers = arrayElement.members;
              const predefinedType = (arrayMembers.length && arrayMembers[0].type) || 'string';
              const hasComplexMembers = arrayElement.isComplex();

              if (!hasComplexMembers) {
                assignValueMemberDefault(valueMember, 'array', predefinedType, valueMemberDefaults);
              } else {
                unrecognizedBlockDetected = true;
                const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
                context.addWarning('Default values of arrays of non-primitive types are not supported', sourceMap);
              }
            }

            if (valueMember.isEnum()) {
              const enumElement = valueMember.content;

              if (!enumElement) {
                unrecognizedBlockDetected = true;
                const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
                context.addWarning(`Enum element "${result.name.string}" should include members.`, sourceMap);
              } else if (!enumElement.isComplex()) {
                assignValueMemberDefault(valueMember, 'enum', enumElement.type, valueMemberDefaults);
              } else {
                unrecognizedBlockDetected = true;
                const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
                context.addWarning('Default values of enum of non-primitive types are not supported', sourceMap);
              }
            }

            const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);
            if (result.content.sourceMap) {
              result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sourceMap]);
            } else {
              result.content.sourceMap = sourceMap;
            }
          }

          let lastNodeOfSection = curNode;
          let nextNode = curNode;
          do {
            lastNodeOfSection = nextNode;
            nextNode = utils.nextNode(nextNode);
          } while (nextNode && nextNode.type !== 'heading');

          if (unrecognizedBlockDetected) {
            const sourceMap = utils.makeGenericSourceMapFromStartAndEndNodes(
              curNode,
              lastNodeOfSection,
              context.sourceLines,
              context.sourceBuffer,
              context.linefeedOffsets,
              context.filename,
            );
            appendUnrecognizedBlocks([sourceMap]);
          }

          curNode = nextNode;
        } else {
          break;
        }
      }

      return [curNode, result];

      function assignValueMemberDefault(valueMember, type, valueType, acc) {
        context.data.typeForDefaults = type;
        context.data.valueType = valueType;

        const [, childResult] = Parsers.DefaultHeaderParser.parse(curNode, context);

        delete context.data.typeForDefaults;
        delete context.data.valueType;

        acc.push(...childResult);

        if (acc.length) {
          const childSourceMaps = acc.map(child => child.sourceMap).flat();

          concatSourceMaps(valueMember, childSourceMaps);

          if (acc.length > 1) {
            const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);

            context.addWarning('Multiple definitions of "default" value', sourceMap);
            appendUnrecognizedBlocks(acc.slice(1).map(d => d.sourceMap).flat());
          }

          if (type === 'enum') {
            valueMember.content.defaultValue = acc[0];
            valueMember.default = acc[0];
          } else {
            valueMember.default = acc[0];
          }
        }
      }

      function appendUnrecognizedBlocks(sourceMaps) {
        result.content.unrecognizedBlocks.push(
          ...sourceMaps.map(sm => new UnrecognizedBlockElement(sm)),
        );

        const sm = utils.concatSourceMaps(sourceMaps);
        if (result.content.sourceMap) {
          result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sm]);
        } else {
          result.content.sourceMap = sm;
        }
      }
    },

    processDescription(node, context, result) {
      if (node && node.type === 'paragraph') {
        const { sourceLines, sourceBuffer, linefeedOffsets, filename } = context;
        const [curNode, desc] = utils.extractDescription(node, sourceLines, sourceBuffer, linefeedOffsets, filename);

        result.description = desc;

        if (result.content.sourceMap) {
          result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, result.description.sourceMap]);
        } else {
          result.content.sourceMap = result.description.sourceMap;
        }

        return [curNode, result];
      }

      return [node, result];
    },

    finalize(context, result) {
      const valueMemberContent = result.content.content;
      const { attributeSignatureDetails } = context.data;

      if (!valueMemberContent) {
        let type = result.content.type || types.object;

        if (context.typeResolver.types[type]) {
          type = context.typeResolver.getStandardBaseType(type);
        }
        fillElementWithContent(result.content, type);
      }

      if (result.content.sourceMap) {
        result.sourceMap = utils.concatSourceMaps([result.sourceMap, result.content.sourceMap]);
      }

      utils.validateAttributesConsistency(context, result.content, attributeSignatureDetails);

      context.popFrame();

      return result;
    },
  });
  return true;
};

function fillElementWithContent(rootElement, elementType, contentMembers) {
  const existingContentElement = rootElement.content;
  let newContentElement;

  if (!rootElement.isComplex()) return;

  switch (elementType) {
    case types.object:
      newContentElement = existingContentElement || new ObjectElement();
      break;
    case types.enum:
      newContentElement = existingContentElement || new EnumElement(rootElement.nestedTypes);
      break;
    case types.array:
      newContentElement = existingContentElement;
      break;
    default:
      break;
  }

  if (Array.isArray(contentMembers)) {
    const membersField = elementType === types.object ? 'propertyMembers' : 'members';
    newContentElement[membersField].push(...contentMembers);

    if (contentMembers.length) {
      const contentMembersSourceMaps = contentMembers.map(cm => cm.sourceMap);
      if (rootElement.sourceMap) {
        rootElement.sourceMap = utils.concatSourceMaps([rootElement.sourceMap, ...contentMembersSourceMaps]);
      } else {
        rootElement.sourceMap = utils.concatSourceMaps(contentMembersSourceMaps);
      }
    }
  }

  rootElement.content = newContentElement;
}

function concatSourceMaps(valueMember, childSourceMaps) {
  if (valueMember.sourceMap) {
    valueMember.sourceMap = utils.concatSourceMaps([valueMember.sourceMap, ...childSourceMaps]);
  } else {
    valueMember.sourceMap = utils.concatSourceMaps(childSourceMaps);
  }
}

1	const SectionTypes = require('../SectionTypes');	12✔
2	const { types } = require('../constants');	12✔
3	const utils = require('../utils');	12✔
4	const { parser: SignatureParser, traits: ParserTraits } = require('../SignatureParser');	12✔
5	const MSONNamedTypeElement = require('./elements/MSONNamedTypeElement');	12✔
6	const ValueMemberElement = require('./elements/ValueMemberElement');	12✔
7	const EnumElement = require('./elements/EnumElement');	12✔
8	const ObjectElement = require('./elements/ObjectElement');	12✔
9	const SchemaNamedTypeElement = require('./elements/SchemaNamedTypeElement');	12✔
10	const UnrecognizedBlockElement = require('./elements/UnrecognizedBlockElement');	12✔
11	const DataStructureProcessor = require('../DataStructureProcessor');	12✔
12	const ValueMemberProcessor = require('../ValueMemberProcessor');	12✔
13
14	const { CrafterError } = utils;	12✔
15
16	module.exports = (Parsers) => {	12✔
17	Parsers.MSONNamedTypeParser = Object.assign(Object.create(require('./AbstractParser')), {	12✔
18	processSignature(node, context) {
19	context.pushFrame();	3,860✔
20
21	const [subject, subjectOffset] = utils.headerTextWithOffset(node, context.sourceLines);	3,860✔
22	const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	3,860✔
23	let signature;
24	try {	3,860✔
25	signature = new SignatureParser(subject, context.languageServerMode, [ParserTraits.NAME, ParserTraits.ATTRIBUTES]);	3,860✔
26	} catch (e) {
27	if (!(e instanceof utils.SignatureError)) {	4!
28	throw e;	×
29	} else {
30	const hashSymbols = Array(node.level).fill('#').join('');	4✔
31	const message = `Invalid NamedType definition. Expected format: "${hashSymbols} Type Name (Type Attributes)".`;	4✔
32	throw new CrafterError(message, sourceMap);	4✔
33	}
34	}
35	signature.warnings.forEach(warning => context.addWarning(warning, sourceMap));	3,856✔
36
37	context.data.attributeSignatureDetails = { sourceMap, node };	3,856✔
38
39	const resolvedType = utils.resolveType(signature.type);	3,856✔
40	const nestedTypes = resolvedType.nestedTypes.map((nestedType, index) => {	3,856✔
41	const el = new ValueMemberElement(nestedType, nestedType, []);	200✔
42	el.sourceMap = utils.makeSourceMapsForString(	200✔
43	nestedType,
44	resolvedType.nestedTypesOffsets[index] + signature.typeOffset + subjectOffset,
45	node,
46	context.sourceLines,
47	context.sourceBuffer,
48	context.linefeedOffsets,
49	context.filename,
50	);
51	return el;	200✔
52	});
53	const valueElement = new ValueMemberElement(	3,856✔
54	signature.type,
55	resolvedType.type,
56	nestedTypes,
57	signature.typeAttributes,
58	);
59
60	const valueMemberSourceMaps = [];	3,856✔
61
62	signature.typeAttributes.forEach((attr, index) => {	3,856✔
63	const [offset, length] = signature.typeAttributesOffsetsAndLengths[index];	228✔
64
65	valueMemberSourceMaps.push(utils.makeSourceMapsForStartPosAndLength(	228✔
66	offset + subjectOffset,
67	length,
68	node,
69	context.sourceLines,
70	context.sourceBuffer,
71	context.linefeedOffsets,
72	context.filename,
73	));
74	});
75
76	if (signature.type) {	3,856✔
77	valueMemberSourceMaps.push(utils.makeSourceMapsForString(	1,860✔
78	signature.type,
79	signature.typeOffset + subjectOffset,
80	node,
81	context.sourceLines,
82	context.sourceBuffer,
83	context.linefeedOffsets,
84	context.filename,
85	));
86	}
87
88	valueMemberSourceMaps.sort((sm1, sm2) => sm1.byteBlocks[0].offset - sm2.byteBlocks[0].offset);	3,856✔
89
90	if (valueMemberSourceMaps.length) {	3,856✔
91	valueElement.sourceMap = utils.concatSourceMaps(valueMemberSourceMaps);	1,896✔
92	}
93
94	const name = utils.makeStringElement(signature.name, signature.nameOffset + subjectOffset, node, context);	3,856✔
95	const typeElement = new MSONNamedTypeElement(name, valueElement, sourceMap);	3,856✔
96
97	if (!context.typeExtractingInProgress) {	3,856✔
98	const typeEl = context.typeResolver.types[signature.type];	2,496✔
99	if (typeEl && typeEl instanceof SchemaNamedTypeElement && !context.languageServerMode) {	2,496✔
100	throw new CrafterError('No inheritance allowed from schema named type.', sourceMap);	4✔
101	}
102
103	try {	2,492✔
104	ValueMemberProcessor.fillBaseType(context, typeElement.content);	2,492✔
105	} catch (error) {
106	if (!error.sourceMap) {	16✔
107	error.sourceMap = typeElement.name.sourceMap;	12✔
108	}
109	throw error;	16✔
110	}
111	}
112
113	return [utils.nextNode(node), typeElement];	3,836✔
114	},
115
116	sectionType(node, context) {
117	if (node.type === 'heading' && context.sectionKeywordSignature(node) === SectionTypes.undefined) {	5,238✔
118	return SectionTypes.MSONNamedType;	3,860✔
119	}
120
121	return SectionTypes.undefined;	1,378✔
122	},
123
124	processNestedSections(node, context, result) {
125	let curNode = node;	3,836✔
126	const valueMemberDefaults = [];	3,836✔
127
128	while (curNode) {	3,836✔
129	if (curNode.type === 'item') {	6,376✔
130	if (!context.typeExtractingInProgress) {	3,000✔
131	const dataStructureProcessor = new DataStructureProcessor(curNode.parent, Parsers, undefined, curNode.parent);	1,928✔
132	const isFixedOrFixedType = result.content.typeAttributes.includes('fixed') \|\| result.content.typeAttributes.includes('fixedType');	1,928✔
133	const isFixedOrFixedTypePropagated = result.content.propagatedTypeAttributes	1,928✔
134	&& (result.content.propagatedTypeAttributes.includes('fixed') \|\| result.content.propagatedTypeAttributes.includes('fixedType'));
135	context.data.isParentAttributeFixedOrFixedType = context.data.isParentAttributeFixedOrFixedType \|\| isFixedOrFixedType \|\| isFixedOrFixedTypePropagated;	1,928✔
136	context.data.isNamedTypeSection = true;	1,928✔
137	dataStructureProcessor.fillValueMember(result.content, context);	1,928✔
138	delete context.data.isParentAttributeFixedOrFixedType;	1,884✔
139	delete context.data.isNamedTypeSection;	1,884✔
140	}
141
142	curNode = utils.nextNode(curNode.parent);	2,956✔
143	} else if (Parsers.NamedTypeMemberGroupParser.sectionType(curNode, context) !== SectionTypes.undefined) {	3,376✔
144	if (!context.typeExtractingInProgress) {	264✔
145	let type = result.content.type \|\| types.object;	176✔
146
147	if (context.typeResolver.types[type]) {	176✔
148	type = context.typeResolver.getStandardBaseType(type);	8✔
149	}
150	context.data.isNamedTypeSection = true;	176✔
151	context.data.parentType = type;	176✔
152	context.data.parentNestedTypes = result.content.nestedTypes;	176✔
153
154	const [nextNode, memberGroup] = Parsers.NamedTypeMemberGroupParser.parse(curNode, context);	176✔
155
156	delete context.data.parentType;	176✔
157	delete context.data.parentNestedTypes;	176✔
158	delete context.data.isNamedTypeSection;	176✔
159
160	if (memberGroup.childValueMember) {	176✔
161	const { childValueMember } = memberGroup;	136✔
162	const rootValueMember = result.content;	136✔
163	const membersField = type === types.object ? 'propertyMembers' : 'members';	136✔
164	const contentMembers = childValueMember.content[membersField];	136✔
165
166	if (!rootValueMember.content) {	136✔
167	rootValueMember.content = childValueMember.content;	96✔
168	} else {
169	rootValueMember.content[membersField].push(...contentMembers);	40✔
170	}
171
172	if (childValueMember.unrecognizedBlocks.length > 0) {	136✔
173	appendUnrecognizedBlocks(childValueMember.unrecognizedBlocks.map(ub => ub.sourceMap));	24✔
174	}
175
176	const contentMembersSourceMaps = contentMembers.map(cm => cm.sourceMap);	296✔
177	if (rootValueMember.sourceMap) {	136✔
178	rootValueMember.sourceMap = utils.concatSourceMaps([rootValueMember.sourceMap, ...contentMembersSourceMaps]);	120✔
179	} else {
180	rootValueMember.sourceMap = utils.concatSourceMaps(contentMembersSourceMaps);	16✔
181	}
182	}
183
184	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	176✔
185	if (result.content.sourceMap) {	176✔
186	result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sourceMap]);	136✔
187	} else {
188	result.content.sourceMap = sourceMap;	40✔
189	}
190
191	curNode = nextNode;	176✔
192	} else {
193	curNode = utils.nextNodeOfType(curNode, 'heading');	88✔
194	}
195	} else if (Parsers.SampleHeaderParser.sectionType(curNode, context) !== SectionTypes.undefined) {	3,112✔
196	let unrecognizedBlockDetected = false;	116✔
197
198	if (!context.typeExtractingInProgress) {	116✔
199	const valueMember = result.content;	76✔
200
201	if (!valueMember.isComplex()) {	76✔
202	context.data.typeForSamples = 'primitive';	16✔
203	context.data.valueType = valueMember.type;	16✔
204	const [, childResult] = Parsers.SampleHeaderParser.parse(curNode, context);	16✔
205	delete context.data.typeForSamples;	16✔
206	delete context.data.valueType;	16✔
207
208	if (childResult.length) {	16!
209	valueMember.samples = valueMember.samples \|\| [];	16!
210	valueMember.samples.push(...childResult);	16✔
211
212	const childSourceMaps = [];	16✔
213	childResult.forEach(child => childSourceMaps.push(child.sourceMap));	24✔
214	concatSourceMaps(valueMember, childSourceMaps);	16✔
215	}
216	}
217
218	if (valueMember.isObject()) {	76✔
219	const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	4✔
220	throw new utils.CrafterError('Sample is not supported for objects', sourceMap);	4✔
221	}
222
223	if (valueMember.isArray()) {	72✔
224	const arrayElement = valueMember.content;	40✔
225	const arrayMembers = arrayElement.members;	40✔
226	const predefinedType = (arrayMembers.length && arrayMembers[0].type) \|\| 'string';	40✔
227	const hasComplexMembers = arrayElement.isComplex();	40✔
228
229	if (!hasComplexMembers) {	40✔
230	context.data.typeForSamples = 'array';	32✔
231	context.data.valueType = predefinedType;	32✔
232	const [, childResult] = Parsers.SampleHeaderParser.parse(curNode, context);	32✔
233	delete context.data.typeForSamples;	32✔
234	delete context.data.valueType;	32✔
235
236	if (childResult.length) {	32!
237	valueMember.samples = valueMember.samples \|\| [];	32!
238	valueMember.samples.push(...childResult);	32✔
239
240	const childSourceMaps = [];	32✔
241	childResult.forEach(child => {	32✔
242	childSourceMaps.push(...child.sourceMap);	32✔
243	});
244	concatSourceMaps(valueMember, childSourceMaps);	32✔
245	}
246	} else {
247	unrecognizedBlockDetected = true;	8✔
248	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	8✔
249	context.addWarning('Samples of arrays of non-primitive types are not supported', sourceMap);	8✔
250	}
251	}
252
253	if (valueMember.isEnum()) {	72✔
254	const enumElement = valueMember.content;	16✔
255	const hasComplexMembers = enumElement.isComplex();	16✔
256
257	if (!hasComplexMembers) {	16!
258	context.data.typeForSamples = 'enum';	16✔
259	context.data.valueType = enumElement.type;	16✔
260	const [, childResult] = Parsers.SampleHeaderParser.parse(curNode, context);	16✔
261	delete context.data.typeForSamples;	16✔
262	delete context.data.valueType;	16✔
263	if (childResult.length) {	16!
264	enumElement.sampleValues = childResult;	16✔
265
266	const childSourceMaps = childResult.map(child => child.sourceMap);	16✔
267	concatSourceMaps(valueMember, childSourceMaps);	16✔
268	}
269	} else {
UNCOV 270	unrecognizedBlockDetected = true;	×
UNCOV 271	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	×
UNCOV 272	context.addWarning('Samples of enum of non-primitive types are not supported', sourceMap);	×
273	}
274	}
275
276	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	72✔
277	if (result.content.sourceMap) {	72!
278	result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sourceMap]);	72✔
279	} else {
280	result.content.sourceMap = sourceMap;	×
281	}
282	}
283
284	let lastNodeOfSection = curNode;	112✔
285	let nextNode = curNode;	112✔
286	do {	112✔
287	lastNodeOfSection = nextNode;	288✔
288	nextNode = utils.nextNode(nextNode);	288✔
289	} while (nextNode && nextNode.type !== 'heading');	500✔
290
291	if (unrecognizedBlockDetected) {	112✔
292	const sourceMap = utils.makeGenericSourceMapFromStartAndEndNodes(	8✔
293	curNode,
294	lastNodeOfSection,
295	context.sourceLines,
296	context.sourceBuffer,
297	context.linefeedOffsets,
298	context.filename,
299	);
300	appendUnrecognizedBlocks([sourceMap]);	8✔
301	}
302
303	curNode = nextNode;	112✔
304	} else if (Parsers.DefaultHeaderParser.sectionType(curNode, context) !== SectionTypes.undefined) {	2,996✔
305	let unrecognizedBlockDetected = false;	248✔
306
307	if (!context.typeExtractingInProgress) {	248✔
308	const valueMember = result.content;	164✔
309
310	if (!valueMember.isComplex()) {	164✔
311	assignValueMemberDefault(valueMember, 'primitive', valueMember.type, valueMemberDefaults);	40✔
312	}
313
314	if (valueMember.isObject()) {	164✔
315	const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	4✔
316	throw new utils.CrafterError('Default is not supported for objects', sourceMap);	4✔
317	}
318
319	if (valueMember.isArray()) {	160✔
320	const arrayElement = valueMember.content;	56✔
321	const arrayMembers = arrayElement.members;	56✔
322	const predefinedType = (arrayMembers.length && arrayMembers[0].type) \|\| 'string';	56✔
323	const hasComplexMembers = arrayElement.isComplex();	56✔
324
325	if (!hasComplexMembers) {	56✔
326	assignValueMemberDefault(valueMember, 'array', predefinedType, valueMemberDefaults);	48✔
327	} else {
328	unrecognizedBlockDetected = true;	8✔
329	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	8✔
330	context.addWarning('Default values of arrays of non-primitive types are not supported', sourceMap);	8✔
331	}
332	}
333
334	if (valueMember.isEnum()) {	160✔
335	const enumElement = valueMember.content;	64✔
336
337	if (!enumElement) {	64✔
338	unrecognizedBlockDetected = true;	8✔
339	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	8✔
340	context.addWarning(`Enum element "${result.name.string}" should include members.`, sourceMap);	8✔
341	} else if (!enumElement.isComplex()) {	56!
342	assignValueMemberDefault(valueMember, 'enum', enumElement.type, valueMemberDefaults);	56✔
343	} else {
UNCOV 344	unrecognizedBlockDetected = true;	×
UNCOV 345	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	×
UNCOV 346	context.addWarning('Default values of enum of non-primitive types are not supported', sourceMap);	×
347	}
348	}
349
350	const sourceMap = utils.makeGenericSourceMap(curNode, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	160✔
351	if (result.content.sourceMap) {	160!
352	result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sourceMap]);	160✔
353	} else {
354	result.content.sourceMap = sourceMap;	×
355	}
356	}
357
358	let lastNodeOfSection = curNode;	244✔
359	let nextNode = curNode;	244✔
360	do {	244✔
361	lastNodeOfSection = nextNode;	576✔
362	nextNode = utils.nextNode(nextNode);	576✔
363	} while (nextNode && nextNode.type !== 'heading');	1,040✔
364
365	if (unrecognizedBlockDetected) {	244✔
366	const sourceMap = utils.makeGenericSourceMapFromStartAndEndNodes(	16✔
367	curNode,
368	lastNodeOfSection,
369	context.sourceLines,
370	context.sourceBuffer,
371	context.linefeedOffsets,
372	context.filename,
373	);
374	appendUnrecognizedBlocks([sourceMap]);	16✔
375	}
376
377	curNode = nextNode;	244✔
378	} else {
379	break;	2,748✔
380	}
381	}
382
383	return [curNode, result];	3,784✔
384
385	function assignValueMemberDefault(valueMember, type, valueType, acc) {
386	context.data.typeForDefaults = type;	144✔
387	context.data.valueType = valueType;	144✔
388
389	const [, childResult] = Parsers.DefaultHeaderParser.parse(curNode, context);	144✔
390
391	delete context.data.typeForDefaults;	144✔
392	delete context.data.valueType;	144✔
393
394	acc.push(...childResult);	144✔
395
396	if (acc.length) {	144!
397	const childSourceMaps = acc.map(child => child.sourceMap).flat();	192✔
398
399	concatSourceMaps(valueMember, childSourceMaps);	144✔
400
401	if (acc.length > 1) {	144✔
402	const sourceMap = utils.makeGenericSourceMap(node, context.sourceLines, context.sourceBuffer, context.linefeedOffsets, context.filename);	48✔
403
404	context.addWarning('Multiple definitions of "default" value', sourceMap);	48✔
405	appendUnrecognizedBlocks(acc.slice(1).map(d => d.sourceMap).flat());	48✔
406	}
407
408	if (type === 'enum') {	144✔
409	valueMember.content.defaultValue = acc[0];	56✔
410	valueMember.default = acc[0];	56✔
411	} else {
412	valueMember.default = acc[0];	88✔
413	}
414	}
415	}
416
417	function appendUnrecognizedBlocks(sourceMaps) {
418	result.content.unrecognizedBlocks.push(	80✔
419	...sourceMaps.map(sm => new UnrecognizedBlockElement(sm)),	112✔
420	);
421
422	const sm = utils.concatSourceMaps(sourceMaps);	80✔
423	if (result.content.sourceMap) {	80!
424	result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, sm]);	80✔
425	} else {
426	result.content.sourceMap = sm;	×
427	}
428	}
429	},
430
431	processDescription(node, context, result) {
432	if (node && node.type === 'paragraph') {	3,836✔
433	const { sourceLines, sourceBuffer, linefeedOffsets, filename } = context;	80✔
434	const [curNode, desc] = utils.extractDescription(node, sourceLines, sourceBuffer, linefeedOffsets, filename);	80✔
435
436	result.description = desc;	80✔
437
438	if (result.content.sourceMap) {	80✔
439	result.content.sourceMap = utils.concatSourceMaps([result.content.sourceMap, result.description.sourceMap]);	36✔
440	} else {
441	result.content.sourceMap = result.description.sourceMap;	44✔
442	}
443
444	return [curNode, result];	80✔
445	}
446
447	return [node, result];	3,756✔
448	},
449
450	finalize(context, result) {
451	const valueMemberContent = result.content.content;	3,784✔
452	const { attributeSignatureDetails } = context.data;	3,784✔
453
454	if (!valueMemberContent) {	3,784✔
455	let type = result.content.type \|\| types.object;	1,676✔
456
457	if (context.typeResolver.types[type]) {	1,676✔
458	type = context.typeResolver.getStandardBaseType(type);	36✔
459	}
460	fillElementWithContent(result.content, type);	1,676✔
461	}
462
463	if (result.content.sourceMap) {	3,784✔
464	result.sourceMap = utils.concatSourceMaps([result.sourceMap, result.content.sourceMap]);	3,040✔
465	}
466
467	utils.validateAttributesConsistency(context, result.content, attributeSignatureDetails);	3,784✔
468
469	context.popFrame();	3,784✔
470
471	return result;	3,784✔
472	},
473	});
474	return true;	12✔
475	};
476
477	function fillElementWithContent(rootElement, elementType, contentMembers) {
478	const existingContentElement = rootElement.content;	1,676✔
479	let newContentElement;
480
481	if (!rootElement.isComplex()) return;	1,676✔
482
483	switch (elementType) {	1,416✔
484	case types.object:
485	newContentElement = existingContentElement \|\| new ObjectElement();	1,000✔
486	break;	1,000✔
487	case types.enum:
488	newContentElement = existingContentElement \|\| new EnumElement(rootElement.nestedTypes);	154✔
489	break;	154✔
490	case types.array:
491	newContentElement = existingContentElement;	130✔
492	break;	130✔
493	default:
494	break;	132✔
495	}
496
497	if (Array.isArray(contentMembers)) {	1,416!
UNCOV 498	const membersField = elementType === types.object ? 'propertyMembers' : 'members';	×
UNCOV 499	newContentElement[membersField].push(...contentMembers);	×
500
UNCOV 501	if (contentMembers.length) {	×
UNCOV 502	const contentMembersSourceMaps = contentMembers.map(cm => cm.sourceMap);	×
UNCOV 503	if (rootElement.sourceMap) {	×
UNCOV 504	rootElement.sourceMap = utils.concatSourceMaps([rootElement.sourceMap, ...contentMembersSourceMaps]);	×
505	} else {
UNCOV 506	rootElement.sourceMap = utils.concatSourceMaps(contentMembersSourceMaps);	×
507	}
508	}
509	}
510
511	rootElement.content = newContentElement;	1,416✔
512	}
513
514	function concatSourceMaps(valueMember, childSourceMaps) {
515	if (valueMember.sourceMap) {	208!
516	valueMember.sourceMap = utils.concatSourceMaps([valueMember.sourceMap, ...childSourceMaps]);	208✔
517	} else {
518	valueMember.sourceMap = utils.concatSourceMaps(childSourceMaps);	×
519	}
520	}

funbox / crafter / 2956299703

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