This is an automated email from the ASF dual-hosted git repository.
davin pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/daffodil-vscode.git
The following commit(s) were added to refs/heads/main by this push:
new 8a1d690 - add missing element items xs:pattern, xs:totalDigits,
xs:fractionDigits, dfdl:property - add missing xs:restriction child elements -
add missing dfdl:escapeScheme element and the escapeScheme attributes - add
missing dfdl:newVariableInstance element - add additional missing dfdl:format
attributes - add a preceeding space if missing when auto completing an
attribute - add additional missing attributes - add a space after inserting an
attribute if missing - add getAnnota [...]
8a1d690 is described below
commit 8a1d690bf712a2eb3db0562c0424dac9e22c8d73
Author: rthomas320 <[email protected]>
AuthorDate: Wed Jul 19 07:35:15 2023 -0400
- add missing element items xs:pattern, xs:totalDigits,
xs:fractionDigits, dfdl:property
- add missing xs:restriction child elements
- add missing dfdl:escapeScheme element and the escapeScheme attributes
- add missing dfdl:newVariableInstance element
- add additional missing dfdl:format attributes
- add a preceeding space if missing when auto completing an attribute
- add additional missing attributes
- add a space after inserting an attribute if missing
- add getAnnotationParent function
- add appinfo switch statement
- add getAnnotationParent function
- add switch statement to appinfo case statement
- add missing dfdl:newVariableINstance to sequence/annotation/appinfo
- Update src/language/providers/attributeCompletion.ts
- Update src/language/providers/elementCompletion.ts
Co-authored-by: Shane Dell <[email protected]>
Closes #587
Closes #588
Closes #591
Closes #592
Closes #593
Closes #609
Closes #624
Closes #629
Closes #630
Closes #637
---
src/language/providers/attributeCompletion.ts | 142 +++++++--
src/language/providers/elementCompletion.ts | 179 ++++++++++--
.../providers/intellisense/attributeItems.ts | 320 ++++++++++++++++-----
.../providers/intellisense/attributeValueItems.ts | 120 +++++++-
src/language/providers/intellisense/commonItems.ts | 2 +-
.../providers/intellisense/elementItems.ts | 72 ++++-
src/language/providers/utils.ts | 6 +-
src/tests/suite/language/items.test.ts | 48 +++-
8 files changed, 752 insertions(+), 137 deletions(-)
diff --git a/src/language/providers/attributeCompletion.ts
b/src/language/providers/attributeCompletion.ts
index b423a8b..28d5d47 100644
--- a/src/language/providers/attributeCompletion.ts
+++ b/src/language/providers/attributeCompletion.ts
@@ -39,7 +39,9 @@ function getCompletionItems(
preVal: string = '',
additionalItems: string = '',
nsPrefix: string,
- dfdlPrefix: string
+ dfdlPrefix: string,
+ spacingChar: string,
+ afterChar: string
) {
let compItems: vscode.CompletionItem[] = getCommonItems(
itemsToUse,
@@ -48,7 +50,13 @@ function getCompletionItems(
nsPrefix
)
- attributeCompletion(dfdlPrefix).items.forEach((e) => {
+ attributeCompletion(
+ additionalItems,
+ nsPrefix,
+ dfdlPrefix,
+ spacingChar,
+ afterChar
+ ).items.forEach((e) => {
if (itemsToUse.includes(e.item)) {
const completionItem = createCompletionItem(e, preVal, nsPrefix)
compItems.push(completionItem)
@@ -69,6 +77,8 @@ export function getAttributeCompletionProvider() {
const triggerText = document
.lineAt(position)
.text.substring(0, position.character)
+ const charBeforeTrigger = triggerText.charAt(position.character - 1)
+ const charAfterTrigger = triggerText.charAt(position.character)
let nearestOpenItem = nearestOpen(document, position)
let itemsOnLine = getItemsOnLineCount(triggerText)
const nsPrefix = getXsdNsPrefix(document, position)
@@ -97,7 +107,9 @@ export function getAttributeCompletionProvider() {
triggerText,
nsPrefix,
preVal,
- additionalItems
+ additionalItems,
+ charBeforeTrigger,
+ charAfterTrigger
)
},
},
@@ -141,20 +153,33 @@ function checkNearestOpenItem(
triggerText: string,
nsPrefix: string,
preVal: string,
- additionalItems: string
+ additionalItems: string,
+ charBeforeTrigger: string,
+ charAfterTrigger: string
): vscode.CompletionItem[] | undefined {
+ const spacingChar: string =
+ charBeforeTrigger !== ' ' &&
+ charBeforeTrigger !== '\n' &&
+ charBeforeTrigger !== '\t'
+ ? ' '
+ : ''
+ const afterChar: string =
+ charAfterTrigger !== ' ' &&
+ charAfterTrigger !== '\n' &&
+ charAfterTrigger !== '\t'
+ ? ' '
+ : ''
switch (nearestOpenItem) {
case 'element':
return getCompletionItems(
[
'name',
'ref',
- 'dfdl:defineFormat',
- 'dfdl:defineEscapeScheme',
'type',
'minOccurs',
'maxOccurs',
'dfdl:occursCount',
+ 'dfdl:bitOrder',
'dfdl:byteOrder',
'dfdl:occursCountKind',
'dfdl:length',
@@ -166,17 +191,22 @@ function checkNearestOpenItem(
'dfdl:inputValueCalc',
'dfdl:outputValueCalc',
'dfdl:alignmentUnits',
+ 'dfdl:binaryNumberRep',
'dfdl:terminator',
'dfdl:outputNewLine',
'dfdl:choiceBranchKey',
'dfdl:prefixIncludesPrefixLength',
'dfdl:prefixLengthType',
'dfdl:representation',
+ 'dfdl:binaryBooleanTrueRep',
+ 'dfdl:binaryBooleanFalseRep',
],
preVal,
additionalItems,
nsPrefix,
- dfdlDefaultPrefix
+ dfdlDefaultPrefix,
+ spacingChar,
+ afterChar
)
case 'sequence':
return getCompletionItems(
@@ -190,7 +220,9 @@ function checkNearestOpenItem(
preVal,
'',
nsPrefix,
- dfdlDefaultPrefix
+ dfdlDefaultPrefix,
+ spacingChar,
+ afterChar
)
case 'choice':
return getCompletionItems(
@@ -204,7 +236,9 @@ function checkNearestOpenItem(
'',
'',
nsPrefix,
- dfdlDefaultPrefix
+ dfdlDefaultPrefix,
+ spacingChar,
+ afterChar
)
case 'group':
return getCompletionItems(
@@ -212,7 +246,9 @@ function checkNearestOpenItem(
'',
'',
nsPrefix,
- dfdlDefaultPrefix
+ dfdlDefaultPrefix,
+ spacingChar,
+ afterChar
)
case 'simpleType':
@@ -222,11 +258,15 @@ function checkNearestOpenItem(
'dfdl:length',
'dfdl:lengthKind',
'dfdl:representation',
+ 'dfdl:binaryBooleanTrueRep',
+ 'dfdl:binaryBooleanFalseRep',
],
'',
'',
nsPrefix,
- dfdlDefaultPrefix
+ dfdlDefaultPrefix,
+ spacingChar,
+ afterChar
)
case 'assert':
return getCompletionItems(
@@ -234,10 +274,20 @@ function checkNearestOpenItem(
'',
'',
nsPrefix,
- ''
+ '',
+ spacingChar,
+ afterChar
)
case 'discriminator':
- return getCompletionItems(['test', 'message'], '', '', nsPrefix, '')
+ return getCompletionItems(
+ ['test', 'message'],
+ '',
+ '',
+ nsPrefix,
+ '',
+ spacingChar,
+ afterChar
+ )
case 'format':
return getCompletionItems(
[
@@ -245,6 +295,9 @@ function checkNearestOpenItem(
'dfdl:bitOrder',
'dfdl:binaryNumberRep',
'dfdl:binaryFloatRep',
+ 'dfdl:binaryDecimalVirtualPoint',
+ 'dfdl:binaryPackedSignCodes',
+ 'dfdl:binaryNumberCheckPolicy',
'dfdl:encoding',
'dfdl:encodingErrorPolicy',
'dfdl:initiator',
@@ -255,6 +308,7 @@ function checkNearestOpenItem(
'dfdl:nilKind',
'dfdl:nilValue',
'dfdl:nilValueDelimiterPolicy',
+ 'dfdl:useNilForDefault',
'dfdl:lengthPattern',
'dfdl:outputNewLine',
'dfdl:separator',
@@ -262,12 +316,14 @@ function checkNearestOpenItem(
'dfdl:separatorSuppressionPolicy',
'dfdl:terminator',
'dfdl:occursCountKind',
+ 'dfdl:decimalSigned',
'dfdl:textStandardZeroRep',
'dfdl:textStandardInfinityRep',
'dfdl:textStandardExponentRep',
'dfdl:textStandardNaNRep',
'dfdl:textNumberPattern',
'dfdl:textNumberRep',
+ 'dfdl:textNumberJustification',
'dfdl:textNumberRoundingIncrement',
'dfdl:textNumberRoundingMode',
'dfdl:textStandardRoundingIncrement',
@@ -275,10 +331,13 @@ function checkNearestOpenItem(
'dfdl:textNumberCheckPolicy',
'dfdl:textOutputMinLength',
'dfdl:textPolicyOutputMinLength',
+ 'dfdl:textStandardDecimalSeparator',
'dfdl:textStandardGroupingSeparator',
'dfdl:textStringJustification',
+ 'dfdl:textStringPadCharacter',
'dfdl:textPadKind',
'dfdl:textStandardBase',
+ 'dfdl:textZonedSignStyle',
'dfdl:textTrimKind',
'dfdl:leadingSkip',
'dfdl:trailingSkip',
@@ -300,17 +359,61 @@ function checkNearestOpenItem(
'dfdl:outputNewLine',
'dfdl:representation',
'dfdl:escapeSchemeRef',
+ 'dfdl:calendarPattern',
'dfdl:calendarPatternKind',
+ 'dfdl:calendarCheckPolicy',
+ 'dfdl:calendarTimeZone',
+ 'dfdl:calendarObserveDST',
+ 'dfdl:calendarFirstDayOfWeek',
+ 'dfdl:calendarDaysInFirstWeek',
+ 'dfdl:calendarCenturyStart',
+ 'dfdl:calendarLanguage',
'dfdl:documentFinalTerminatorCanBeMissing',
'dfdl:emptyValueDelimiterPolicy',
+ 'dfdl:emptyElementParsePolicy',
+ ],
+ '',
+ '',
+ nsPrefix,
+ '',
+ spacingChar,
+ afterChar
+ )
+ case 'escapeScheme':
+ return getCompletionItems(
+ [
+ 'dfdl:escapeKind',
+ 'dfdl:escapeCharacter',
+ 'dfdl:escapeBlockStart',
+ 'dfdl:escapeBlockEnd',
+ 'dfdl:escapeEscapeCharacter',
+ 'dfdl:extraEscapedCharacters',
+ 'dfdl:generateEscapeBlock',
+ 'dfdl:escapeCharacterPolicy',
],
'',
'',
nsPrefix,
- ''
+ '',
+ spacingChar,
+ afterChar
)
case 'defineVariable':
- return getDefineVariableCompletionItems(preVal, additionalItems,
nsPrefix)
+ return getDefineVariableCompletionItems(
+ preVal,
+ additionalItems,
+ nsPrefix,
+ spacingChar,
+ afterChar
+ )
+ case 'newVariableInstance':
+ return getDefineVariableCompletionItems(
+ preVal,
+ additionalItems,
+ nsPrefix,
+ spacingChar,
+ afterChar
+ )
case 'setVariable':
const xmlValue = new vscode.CompletionItem('value')
xmlValue.insertText = new vscode.SnippetString('value="$1"$0')
@@ -324,16 +427,19 @@ function checkNearestOpenItem(
function getDefineVariableCompletionItems(
preVal: string,
additionalItems: string,
- nsPrefix: string
+ nsPrefix: string,
+ spacingChar: string,
+ afterChar: string
): vscode.CompletionItem[] {
let xmlItems = [
{
item: 'external',
- snippetString: preVal + 'external="${1|true,false|}"$0',
+ snippetString:
+ spacingChar + preVal + 'external="${1|true,false|}"$0' + afterChar,
},
{
item: 'defaultValue',
- snippetString: preVal + 'defaultValue="0$1"$0',
+ snippetString: spacingChar + preVal + 'defaultValue="0$1"$0' + afterChar,
},
]
diff --git a/src/language/providers/elementCompletion.ts
b/src/language/providers/elementCompletion.ts
index d3a7c0b..492b0f2 100644
--- a/src/language/providers/elementCompletion.ts
+++ b/src/language/providers/elementCompletion.ts
@@ -74,7 +74,7 @@ export function
getElementCompletionProvider(dfdlFormatString: string) {
let definedVariables = getDefinedVariables(document)
- let tagNearestTrigger = getTagNearestTrigger(
+ let [tagNearestTrigger, tagPosition] = getTagNearestTrigger(
document,
position,
triggerText,
@@ -84,10 +84,11 @@ export function
getElementCompletionProvider(dfdlFormatString: string) {
nsPrefix
)
- return checkTagNearestOpen(
+ return nearestOpenTagChildElements(
document,
position,
tagNearestTrigger,
+ tagPosition,
definedVariables,
nsPrefix
)
@@ -153,10 +154,11 @@ function getDefinedVariables(document:
vscode.TextDocument) {
return additionalTypes
}
-function checkTagNearestOpen(
+function nearestOpenTagChildElements(
document: vscode.TextDocument,
position: vscode.Position,
tagNearestTrigger: string,
+ tagPosition: vscode.Position,
definedVariables: string,
nsPrefix: string
) {
@@ -205,7 +207,16 @@ function checkTagNearestOpen(
)
case 'restriction':
return getElementCompletionItems(
- ['maxInclusive', 'maxExclusive', 'minInclusive', 'minExclusive'],
+ [
+ 'maxInclusive',
+ 'maxExclusive',
+ 'minInclusive',
+ 'minExclusive',
+ 'pattern',
+ 'totalDigits',
+ 'fractionDigits',
+ 'enumeration',
+ ],
'',
'',
nsPrefix
@@ -213,28 +224,103 @@ function checkTagNearestOpen(
case 'annotation':
return getElementCompletionItems(['appinfo'], '', '', nsPrefix)
case 'appinfo':
- return getElementCompletionItems(
- [
- 'dfdl:assert',
- 'dfdl:discriminator',
- 'dfdl:defineFormat',
- 'dfdl:format',
- 'dfdl:defineVariable',
- 'dfdl:setVariable',
- 'dfdl:defineEscapeScheme',
- 'dfdl:element',
- 'dfdl:simpleType',
- ],
- '',
- '',
- nsPrefix
- )
+ let triggerText = document.lineAt(tagPosition.line).text
+ let iCount = getItemsOnLineCount(triggerText)
+ const newPosition =
+ iCount < 2
+ ? new vscode.Position(tagPosition.line - 1, tagPosition.character)
+ : tagPosition
+ let pElement = getAnnotationParent(document, newPosition, nsPrefix)
+ switch (pElement) {
+ case 'schema':
+ return getElementCompletionItems(
+ [
+ 'dfdl:defineFormat',
+ 'dfdl:defineVariable',
+ 'dfdl:defineEscapeScheme',
+ 'dfdl:format',
+ ],
+ '',
+ '',
+ nsPrefix
+ )
+ case 'element':
+ return getElementCompletionItems(
+ ['dfdl:assert', 'dfdl:discriminator', 'dfdl:setVariable'],
+ '',
+ '',
+ nsPrefix
+ )
+ case 'element ref':
+ return getElementCompletionItems(
+ ['dfdl:assert', 'dfdl:discriminator', 'dfdl:setVariable'],
+ '',
+ '',
+ nsPrefix
+ )
+ case 'sequence':
+ return getElementCompletionItems(
+ [
+ 'dfdl:assert',
+ 'dfdl:discriminator',
+ 'dfdl:newVariableInstance',
+ 'dfdl:sequence',
+ ],
+ '',
+ '',
+ nsPrefix
+ )
+ case 'choice':
+ return getElementCompletionItems(
+ [
+ 'dfdl:assert',
+ 'dfdl:choice',
+ 'dfdl:discriminator',
+ 'dfdl:newVariableInstance',
+ 'dfdl:setVariable',
+ ],
+ '',
+ '',
+ nsPrefix
+ )
+ case 'group ref':
+ return getElementCompletionItems(
+ [
+ 'dfdl:assert',
+ 'dfdl:group',
+ 'dfdl:discriminator',
+ 'dfdl:newVariableInstance',
+ 'dfdl:setVariable',
+ ],
+ '',
+ '',
+ nsPrefix
+ )
+ case 'simpleType':
+ return getElementCompletionItems(
+ [
+ 'dfdl:assert',
+ 'dfdl:discriminator',
+ 'dfdl:setVariable',
+ 'dfdl:simpleType',
+ ],
+ '',
+ '',
+ nsPrefix
+ )
+ default:
+ return undefined
+ }
case 'assert':
return getElementCompletionItems(['CDATA', '{}'], '', '', nsPrefix)
case 'discriminator':
return getElementCompletionItems(['CDATA', '{}'], '', '', nsPrefix)
case 'defineFormat':
- return getElementCompletionItems(['format'], '', '', nsPrefix)
+ return getElementCompletionItems(['dfdl:format'], '', '', nsPrefix)
+ case 'defineEscapeScheme':
+ return getElementCompletionItems(['dfdl:escapeScheme'], '', '', nsPrefix)
+ case 'format':
+ return getElementCompletionItems(['dfdl:property'], '', '', nsPrefix)
case 'schema':
return getElementCompletionItems(
[
@@ -259,6 +345,47 @@ function checkTagNearestOpen(
}
}
+export function getAnnotationParent(
+ document: vscode.TextDocument,
+ tagPosition: vscode.Position,
+ nsPrefix: string
+): string {
+ let pElementText = document.lineAt(tagPosition.line).text
+ let iCount = getItemsOnLineCount(pElementText)
+ let pElement = ''
+ let [nElement, newPosition] = getTagNearestTrigger(
+ document,
+ tagPosition,
+ pElementText,
+ tagPosition.line,
+ tagPosition.character,
+ iCount,
+ nsPrefix
+ )
+ pElement = nElement
+ //get parent of annotation tag
+ if (pElement === 'annotation') {
+ if (iCount < 2) {
+ newPosition = new vscode.Position(
+ newPosition.line - 1,
+ newPosition.character
+ )
+ }
+ pElementText = document.lineAt(newPosition.line).text
+ let [nElement] = getTagNearestTrigger(
+ document,
+ newPosition,
+ pElementText,
+ newPosition.line,
+ newPosition.character,
+ iCount,
+ nsPrefix
+ )
+ pElement = nElement
+ }
+ return pElement
+}
+
export function getTagNearestTrigger(
document: vscode.TextDocument,
position: vscode.Position,
@@ -267,7 +394,7 @@ export function getTagNearestTrigger(
triggerPos: number,
itemsOnLine: number,
nsPrefix: string
-): string {
+): [string, vscode.Position] {
let [startLine, startPos] = [triggerLine, triggerPos]
let tagNearestTrigger = 'none'
@@ -276,7 +403,7 @@ export function getTagNearestTrigger(
document.lineCount === 1 &&
position.character === 0
) {
- return 'emptySchema'
+ return ['emptySchema', position]
}
while (true) {
@@ -304,7 +431,7 @@ export function getTagNearestTrigger(
!beforeTriggerTag.startsWith('</')
) {
tagNearestTrigger = foundTag
- return tagNearestTrigger
+ return [tagNearestTrigger, new vscode.Position(foundLine, foundPos)]
}
}
@@ -322,7 +449,7 @@ export function getTagNearestTrigger(
if (itemsOnLine > 1 && foundLine === triggerLine) {
if (foundTag === endTag && endTagPos >= triggerPos) {
tagNearestTrigger = foundTag
- return tagNearestTrigger
+ return [tagNearestTrigger, new vscode.Position(foundLine, foundPos)]
}
if (endTag === 'none') {
@@ -338,7 +465,7 @@ export function getTagNearestTrigger(
endTag === 'xml version'
) {
tagNearestTrigger = foundTag
- return tagNearestTrigger
+ return [tagNearestTrigger, new vscode.Position(foundLine, foundPos)]
}
startLine = foundLine - 1
diff --git a/src/language/providers/intellisense/attributeItems.ts
b/src/language/providers/intellisense/attributeItems.ts
index e17d47b..b999a41 100644
--- a/src/language/providers/intellisense/attributeItems.ts
+++ b/src/language/providers/intellisense/attributeItems.ts
@@ -16,367 +16,533 @@
*/
// prettier-ignore
-export const attributeCompletion = (dfdlPrefix: string) => {
+export const attributeCompletion = (
+ additionalItems,
+ nsPrefix: string,
+ dfdlPrefix: string,
+ spacingChar: string,
+ afterChar: string
+ ) => {
return {
items: [
{
item: 'name',
- snippetString: 'name="$1"$0',
+ snippetString: spacingChar + 'name="$1"$0' + afterChar,
markdownString: 'specify name',
},
{
item: 'ref',
- snippetString: 'ref="$1"$0',
- markdownString: 'specify reference name'
+ snippetString: spacingChar + 'ref="$1"$0' + afterChar,
+ markdownString: 'Specifies the name of an element in this schema'
},
{
item: 'minOccurs',
- snippetString: 'minOccurs="${1|0,1|}"$0',
+ snippetString: spacingChar + 'minOccurs="${1|0,1|}"$0' + afterChar,
markdownString: 'Minimum number of times element will occur',
},
{
item: 'maxOccurs',
- snippetString: 'maxOccurs="${1|0,1,unbounded|}"$0',
+ snippetString: spacingChar + 'maxOccurs="${1|0,1,unbounded|}"$0' +
afterChar,
markdownString: 'Maximum number of times element will occur',
},
{
item: 'dfdl:occursCount',
- snippetString: dfdlPrefix + 'occursCount="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'occursCount="$1"$0' +
afterChar,
markdownString: 'dfdl:occursCount property takes an expression which
commonly looks in the Infoset via an expression, to obtain the count from
another element.',
},
{
item: 'dfdl:byteOrder',
- snippetString: dfdlPrefix +
'byteOrder="${1|bigEndian,littleEndian|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'byteOrder="${1|bigEndian,littleEndian|}"$0' + afterChar,
markdownString: 'This property applies to all Number, Calendar (date
and time), and Boolean types with representation binary',
},
{
item: 'dfdl:bitOrder',
- snippetString: dfdlPrefix +
'bitOrder="${1|mostSignificantBitFirst,leastSignificantBitFirst|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'bitOrder="${1|mostSignificantBitFirst,leastSignificantBitFirst|}"$0' +
afterChar,
markdownString: 'Determines the specific bits of any grammar region',
},
{
item: 'dfdl:occursCountKind',
- snippetString: dfdlPrefix +
'occursCountKind="${1|expression,fixed,implicit,parsed,stopValue|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'occursCountKind="${1|expression,fixed,implicit,parsed,stopValue|}"$0' +
afterChar,
markdownString: 'Specifies how the actual number of occurrences is to
be established',
},
{
item: 'dfdl:length',
- snippetString: dfdlPrefix + 'length="$1"$0',
- markdownString: 'length can be an expression that resolves to an
unsigned integer, or a literal unsigned integer',
+ snippetString: spacingChar + dfdlPrefix + 'length="$1"$0',
+ markdownString: 'length can be an expression that resolves to an
unsigned integer, or a literal unsigned integer' + afterChar,
},
{
item: 'dfdl:lengthKind',
- snippetString: dfdlPrefix +
'lengthKind="${1|delimited,fixed,explicit,implicit,prefixed,pattern,endOfParent|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'lengthKind="${1|delimited,fixed,explicit,implicit,prefixed,pattern,endOfParent|}"$0'
+ afterChar,
markdownString: 'lengthKind can be delimited, fixed, explicit,
implicit, prefixed,pattern, or endOfParent',
},
{
item: 'dfdl:prefixIncludesPrefixLength',
- snippetString: dfdlPrefix +
'prefixIncludesPrefixLength="${1|yes,no|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'prefixIncludesPrefixLength="${1|yes,no|}"$0' + afterChar,
markdownString: 'Specifies whether the length given by a prefix
includes the length of the prefix as well as the length of the content region',
},
{
item: 'dfdl:prefixLengthType',
- snippetString: dfdlPrefix + 'prefixLengthType="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'prefixLengthType="$1"$0' +
afterChar,
markdownString: 'Name of a simple type derived from xs:integer or any
subtype of it.',
},
{
item: 'dfdl:utf16Width',
- snippetString: dfdlPrefix + 'utf16Width="${1|fixed,variable|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'utf16Width="${1|fixed,variable|}"$0' + afterChar,
markdownString: 'Specifies whether the encoding UTF-16 is treated as a
fixed or variable width encoding',
},
{
item: 'dfdl:encoding',
- snippetString: dfdlPrefix +
'encoding="${1|US-ASCII,ASCII,UTF-8,UTF-16,UTF-16BE,UTF-16LE,ISO-8859-1|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'encoding="${1|US-ASCII,ASCII,UTF-8,UTF-16,UTF-16BE,UTF-16LE,ISO-8859-1|}"$0' +
afterChar,
markdownString: 'This property can be computed by way of an expression
which returns an appropriate string value',
},
{
item: 'dfdl:encodingErrorPolicy',
- snippetString: dfdlPrefix +
'encodingErrorPolicy="${1|error,replace|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'encodingErrorPolicy="${1|error,replace|}"$0' + afterChar,
markdownString: 'This property provides control of how decoding and
encoding errors are handled when converting the data to text, or text to data',
},
{
item: 'dfdl:nilKind',
- snippetString: dfdlPrefix +
'nilKind="${1|literalCharacter,literalValue,logicalValue|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'nilKind="${1|literalCharacter,literalValue,logicalValue|}"$0' + afterChar,
markdownString: 'Specifies how dfdl:<nilValue> is interpreted to
represent the nil value in the data stream'
},
{
item: 'dfdl:nilValue',
- snippetString: dfdlPrefix + 'nilValue="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'nilValue="$1"$0' +
afterChar,
markdownString: 'Used to provide a logical value that is used to
indicate the data is nilled'
},
{
item: 'dfdl:nilValueDelimiterPolicy',
- snippetString: dfdlPrefix +
'nilValueDelimiterPolicy="${1|initiator,terminator,both,none|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'nilValueDelimiterPolicy="${1|initiator,terminator,both,none|}"$0' + afterChar,
markdownString: 'Controls whether matching one of the nil values also
involves matching the initiator or terminator specified by the element',
},
+ {
+ item: 'dfdl:useNilForDefault',
+ snippetString: spacingChar + dfdlPrefix +
'useNilForDefault="${1|yes,no|}"$0' + afterChar,
+ markdownString: 'Controls whether to set the Infoset item [nilled]
boolean member, or to use the XSD default or fixed properties to obtain a data
value'
+ },
{
item: 'dfdl:alignment',
- snippetString: dfdlPrefix + 'alignment="${1|1,2,implicit|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'alignment="${1|1,2,implicit|}"$0' + afterChar,
markdownString: "Alignment required for the beginning of the
item.\nCan be non-negative integer or 'implicit'.",
},
{
item: 'dfdl:lengthUnits',
- snippetString: dfdlPrefix +
'lengthUnits="${1|bits,bytes,characters|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'lengthUnits="${1|bits,bytes,characters|}"$0' + afterChar,
markdownString: 'lengthUnits can be specified as bits, bytes, or
characters',
},
{
item: 'dfdl:lengthPattern',
- snippetString: dfdlPrefix + 'lengthPattern="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'lengthPattern="$1"$0' +
afterChar,
markdownString: 'lengthPattern takes a regular expression which is
used to scan the data stream for matching data',
},
{
item: 'dfdl:inputValueCalc',
- snippetString: dfdlPrefix + 'inputValueCalc="{$1}"$0',
+ snippetString: spacingChar + dfdlPrefix + 'inputValueCalc="{$1}"$0' +
afterChar,
markdownString: 'An expression that calculates the value of the
element when parsing',
},
{
item: 'dfdl:outputValueCalc',
- snippetString: dfdlPrefix + 'outputValueCalc="{$1}"$0',
+ snippetString: spacingChar + dfdlPrefix + 'outputValueCalc="{$1}"$0' +
afterChar,
markdownString: 'An expression that calculates the value of the
current element when unparsing',
},
{
item: 'dfdl:alignmentUnits',
- snippetString: dfdlPrefix + 'alignmentUnits="${1|bits,bytes|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'alignmentUnits="${1|bits,bytes|}"$0' + afterChar,
markdownString: "Scales the alignment.\nCan only be used when
alignment is bits or bytes.\nValid values are 'bits or 'bytes'.",
},
{
item: 'dfdl:outputNewLine',
- snippetString: dfdlPrefix +
'outputNewLine="${1|%CR;,%LF;,%CR;%LF;,%NEL;,%LS;|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'outputNewLine="${1|%CR;,%LF;,%CR;%LF;,%NEL;,%LS;|}"$0' + afterChar,
markdownString: 'Specifies the character or characters that are used
to replace the %NL; character class entity during unparse',
},
{
item: 'dfdl:choiceBranchKey',
- snippetString: dfdlPrefix + 'choiceBranchKey="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'choiceBranchKey="$1"$0' +
afterChar,
markdownString: 'List of DFDL String Literals',
},
{
item: 'dfdl:representation',
- snippetString: dfdlPrefix + 'representation="${1|binary,text|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'representation="${1|binary,text|}"$0' + afterChar,
markdownString: 'Identifies the physical representation of the element
as text or binary',
},
{
item: 'dfdl:textStringJustification',
- snippetString: dfdlPrefix +
'textStringJustification="${1|left,right,center|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textStringJustification="${1|left,right,center|}"$0' + afterChar,
+ markdownString: 'Specifies the string justification',
+ },
+ {
+ item: 'dfdl:textStringPadCharacter',
+ snippetString: spacingChar + dfdlPrefix +
'textStringPadCharacter="$1"$0' + afterChar,
markdownString: 'Specifies the string justification',
},
{
item: 'dfdl:textStandardZeroRep',
- snippetString: dfdlPrefix + 'textStandardZeroRep="0"$0',
+ snippetString: spacingChar + dfdlPrefix + 'textStandardZeroRep="0"$0'
+ afterChar,
markdownString: 'Specifies the whitespace separated list of
alternative DFDL String Literals that are equivalent to zero ',
},
{
item: 'dfdl:textStandardInfinityRep',
- snippetString: dfdlPrefix + 'textStandardInfinityRep="Inf"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textStandardInfinityRep="Inf"$0' + afterChar,
markdownString: 'The value used to represent infinity.',
},
{
item: 'dfdl:textStandardExponentRep',
- snippetString: dfdlPrefix + 'textStandardExponentRep="E"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textStandardExponentRep="E"$0' + afterChar,
markdownString: 'Defines the actual character(s) that appear in the
data as the exponent indicator',
},
{
item: 'dfdl:textStandardNaNRep',
- snippetString: dfdlPrefix + 'textStandardNaNRep="NaN"$0',
+ snippetString: spacingChar + dfdlPrefix + 'textStandardNaNRep="NaN"$0'
+ afterChar,
markdownString: 'Specifies the value used to represent NaN ',
},
{
item: 'dfdl:textNumberPattern',
- snippetString: dfdlPrefix +
'textNumberPattern="#,##0.###;-#,##0.###"$0',
- markdownString: 'Defines the ICU-like pattern that describes the
format of the text number',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberPattern="#,##0.###;-#,##0.###"$0' + afterChar,
+ markdownString: 'Indicates whether an xs:decimal element is signed',
+ },
+ {
+ item: 'dfdl:decimalSigned',
+ snippetString: spacingChar + dfdlPrefix +
'decimalSigned="${1|yes,no|}"$0' + afterChar,
+ markdownString: 'Represented as standard characters in the character
set encoding or represented as a zoned decimal in the character set encoding',
},
{
item: 'dfdl:textNumberRep',
- snippetString: dfdlPrefix + 'textNumberRep="${1|standard,zoned|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberRep="${1|standard,zoned|}"$0' + afterChar,
markdownString: 'Represented as standard characters in the character
set encoding or represented as a zoned decimal in the character set encoding',
},
+ {
+ item: 'dfdl:textNumberJustification',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberJustification=${1|left,right,center|}"$0' + afterChar,
+ markdownString: 'Controls how the data is padded or trimmed on parsing
and unparsing',
+ },
{
item: 'dfdl:textNumberRoundingMode',
- snippetString: dfdlPrefix +
'textNumberRoundingMode="${1|roundCeiling,roundFloor,roundDown,roundUp,roundHalfEven,roundHalfDown,roundHalfUp,roundUnnecessary|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberRoundingMode="${1|roundCeiling,roundFloor,roundDown,roundUp,roundHalfEven,roundHalfDown,roundHalfUp,roundUnnecessary|}"$0'
+ afterChar,
markdownString: 'Specifies how rounding occurs during unparsing',
},
{
item: 'dfdl:textNumberRoundingIncrement',
- snippetString: dfdlPrefix + 'textNumberRoundingIncrement="0"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberRoundingIncrement="0"$0' + afterChar,
markdownString: 'Specifies the rounding increment to use during
unparsing',
},
{
item: 'dfdl:textNumberRounding',
- snippetString: dfdlPrefix +
'textNumberRounding="${1|explicit,pattern|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberRounding="${1|explicit,pattern|}"$0' + afterChar,
markdownString: 'Specifies how rounding is controlled during
unparsing',
},
{
item: 'dfdl:textNumberCheckPolicy',
- snippetString: dfdlPrefix +
'textNumberCheckPolicy="${1|lax,strict|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textNumberCheckPolicy="${1|lax,strict|}"$0' + afterChar,
markdownString: 'Indicates how lenient to be when parsing against the
dfdl:textNumberPattern',
},
{
item: 'dfdl:textOutputMinLength',
- snippetString: dfdlPrefix + 'textOutputMinLength="0"$0',
+ snippetString: spacingChar + dfdlPrefix + 'textOutputMinLength="0"$0'
+ afterChar,
markdownString: 'Specifies the minimum content length during unparsing
for simple types that do not allow the XSD minLength facet to be specified',
},
+ {
+ item: 'dfdl:textStandardDecimalSeparator',
+ snippetString: spacingChar + 'dfdl:textStandardDecimalSeparator=","$0'
+ afterChar,
+ markdownString: 'Defines a whitespace separated list of single
characters that appear (individually) in the data as the decimal separator',
+ },
{
item: 'dfdl:textStandardGroupingSeparator',
- snippetString: 'ddl:textStandardGroupingSeparator=","$0',
+ snippetString: spacingChar +
'dfdl:textStandardGroupingSeparator=","$0' + afterChar,
markdownString: 'Specifies the single character that can appear in the
data as the grouping separator',
},
{
item: 'dfdl:textPadKind',
- snippetString: dfdlPrefix + 'textPadKind="${1|none,padChar|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textPadKind="${1|none,padChar|}"$0' + afterChar,
markdownString: 'Indicates whether to pad the data value on unparsing',
},
{
item: 'dfdl:textStandardBase',
- snippetString: dfdlPrefix + 'textStandardBase="${1|2,8,10,16|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textStandardBase="${1|2,8,10,16|}"$0' + afterChar,
markdownString: 'Indicates the number base',
},
+ {
+ item: 'dfdl:textZonedSignStyle',
+ snippetString: spacingChar + dfdlPrefix + 'textZonedSignStyle="$1"$0'
+ afterChar,
+ markdownString: 'Specifies the code points that are used to modify the
sign nibble of the byte containing the sign',
+ },
{
item: 'dfdl:textTrimKind',
- snippetString: dfdlPrefix + 'textTrimKind="${1|none,padChar|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'textTrimKind="${1|none,padChar|}"$0' + afterChar,
markdownString: 'Indicates whether to trim data on parsing',
},
+ {
+ item: 'dfdl:textBooleanTrueRep',
+ snippetString: spacingChar + dfdlPrefix + 'textBooleanTrueRep="$1"$0'
+ afterChar,
+ markdownString: 'A whitespace separated list of representations to be
used for true',
+ },
+ {
+ item: 'dfdl:textBooleanFalseRep',
+ snippetString: spacingChar + dfdlPrefix + 'textBooleanFalseRep="$1"$0'
+ afterChar,
+ markdownString: 'A whitespace separated list of representations to be
used for false',
+ },
+ {
+ item: 'dfdl:textBooleanJustification',
+ snippetString: spacingChar + dfdlPrefix +
'textBooleanJustification="${1|left,right,center|}"$0' + afterChar,
+ markdownString: 'Controls how the data is padded or trimmed on parsing
and unparsing',
+ },
+ {
+ item: 'dfdl:textBooleanPadCharacter',
+ snippetString: spacingChar + dfdlPrefix +
'textBooleanPadCharacter="$1"$0' + afterChar,
+ markdownString: 'The value that is used when padding or trimming
boolean elements',
+ },
{
item: 'dfdl:leadingSkip',
- snippetString: dfdlPrefix + 'leadingSkip="0$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'leadingSkip="0$1"$0' +
afterChar,
markdownString: 'A non-negative number of bytes or bits to skip before
alignment is applied',
},
{
item: 'dfdl:trailingSkip',
- snippetString: dfdlPrefix + 'trailingSkip="0$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'trailingSkip="0$1"$0' +
afterChar,
markdownString: 'A non-negative number of bytes or bits to skip after
the element,',
},
{
item: 'dfdl:truncateSpecifiedLengthString',
- snippetString: dfdlPrefix +
'truncateSpecifiedLengthString="${1|no,yes|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'truncateSpecifiedLengthString="${1|no,yes|}"$0' + afterChar,
markdownString: 'This property provides the means to express an error,
or the strings can be truncated to fit when the strings in an Infoset being
unparsed do not fit within those specified lengths',
},
{
item: 'dfdl:sequenceKind',
- snippetString: dfdlPrefix + 'SequenceKind
="${1|ordered,unordered|}"$0',
+ snippetString: spacingChar + dfdlPrefix + 'SequenceKind
="${1|ordered,unordered|}"$0' + afterChar,
markdownString: 'Defines whether the items are expected in the same
order that they appear in the schema or in any order',
},
{
item: 'dfdl:separator',
- snippetString: dfdlPrefix + 'separator="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'separator="$1"$0' +
afterChar,
markdownString: 'Specifies a whitespace separated list of alternative
DFDL String Literals that are the possible separators for the sequence',
},
{
item: 'dfdl:separatorPosition',
- snippetString: dfdlPrefix +
'separatorPosition="${1|infix,postfix,prefix|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'separatorPosition="${1|infix,postfix,prefix|}"$0' + afterChar,
markdownString: 'specifies where the separator occurs between the
elements',
},
{
item: 'dfdl:separatorSuppressionPolicy',
- snippetString: dfdlPrefix +
'separatorSuppressionPolicy="${1|anyEmpty,never,trailingEmpty,trailingEmptyStrict|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'separatorSuppressionPolicy="${1|anyEmpty,never,trailingEmpty,trailingEmptyStrict|}"$0'
+ afterChar,
markdownString: 'Controls the circumstances when separators are
expected in the data when parsing, or generated when unparsing',
},
{
item: 'dfdl:terminator',
- snippetString: dfdlPrefix + 'terminator="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'terminator="$1"$0' +
afterChar,
markdownString: 'charater or bytes found in the input stream that
designate termination of an element',
},
{
item: 'dfdl:textBidi',
- snippetString: dfdlPrefix + 'textBidi="${1|no,yes|}"$0',
+ snippetString: spacingChar + dfdlPrefix + 'textBidi="${1|no,yes|}"$0'
+ afterChar,
markdownString: 'This property exists in anticipation of future DFDL
features that enable bidirectional text processing',
},
{
item: 'dfdl:hiddenGroupRef',
- snippetString: 'dfdl:hiddenGroupRef="$1"$0',
+ snippetString: spacingChar + 'dfdl:hiddenGroupRef="$1"$0' + afterChar,
markdownString: 'Reference to a global model group definition',
},
{
item: 'dfdl:choiceLengthKind',
- snippetString: dfdlPrefix +
'choiceLengthKind="${1|explicit,implicit|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'choiceLengthKind="${1|explicit,implicit|}"$0' + afterChar,
markdownString: 'Determines whether the branches of the choice are
always filled (explicit) to the fixed-length specified by dfdl:choiceLength or
not filled (implicit)',
},
{
item: 'dfdl:choiceLength',
- snippetString: dfdlPrefix + 'choiceLength="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'choiceLength="$1"$0' +
afterChar,
markdownString: 'Specifies the length of the choice in bytes, only
used when dfdl:choiceLengthKind is explicit',
},
{
item: 'dfdl:fillByte',
- snippetString: dfdlPrefix + 'fillByte="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'fillByte="$1"$0' +
afterChar,
markdownString: 'A single byte specified as a DFDL byte value entity
or a single character, used on unparsing to fill empty space',
},
{
item: 'dfdl:ignoreCase',
- snippetString: dfdlPrefix + 'ignoreCase="${1|no,yes|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'ignoreCase="${1|no,yes|}"$0' + afterChar,
markdownString: 'Whether mixed case data is accepted when matching
delimiters and data values on input',
},
{
item: 'dfdl:initiatedContent',
- snippetString: dfdlPrefix + 'initiatedContent="${1|yes,no|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'initiatedContent="${1|yes,no|}"$0' + afterChar,
markdownString: 'yes indicates all branches of a choice are
initiated\nno indicates the branch dfdl:initator property may be ste to empty
string',
},
{
item: 'dfdl:initiator',
- snippetString: dfdlPrefix + 'initiator="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'initiator="$1"$0' +
afterChar,
markdownString: 'Specifies an ordered whitespace separated list of
alternative DFDL String Literals one of which marks the beginning of the
element or group of elements ',
},
{
item: 'dfdl:choiceDispatchKey',
- snippetString: dfdlPrefix + 'choiceDispatchKey="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'choiceDispatchKey="$1"$0' +
afterChar,
markdownString: 'The expression must evaluate to a string, the string
must match one of the dfdl:choiceBranchKey property values of one of the
branches of the choice',
},
{
item: 'dfdl:binaryNumberRep',
- snippetString: dfdlPrefix +
'binaryNumberRep="${1|binary,packed,bcd,ibm4690Packed|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'binaryNumberRep="${1|binary,packed,bcd,ibm4690Packed|}"$0' + afterChar,
markdownString: 'binary,packed,bcd, or ibm4690Packed',
},
{
item: 'dfdl:floating',
- snippetString: dfdlPrefix + 'floating="${1|no,yes|}"$0',
+ snippetString: spacingChar + dfdlPrefix + 'floating="${1|no,yes|}"$0'
+ afterChar,
markdownString: 'yes or no',
},
{
item: 'dfdl:binaryFloatRep',
- snippetString: dfdlPrefix + 'binaryFloatRep="${1|ieee,ibm390Hex|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'binaryFloatRep="${1|ieee,ibm390Hex|}"$0' + afterChar,
markdownString: 'ieee or ibm390Hex',
},
+ {
+ item: 'dfdl:binaryDecimalVirtualPoint',
+ snippetString: spacingChar + dfdlPrefix +
'binaryDecimalVirtualPoint="$1"$0' + afterChar,
+ markdownString: 'An integer that represents the position of an implied
decimal point within a number',
+ },
+ {
+ item: 'dfdl:binaryPackedSignCodes',
+ snippetString: spacingChar + dfdlPrefix +
'binaryPackedSignCodes="$1"$0' + afterChar,
+ markdownString: 'A whitespace separated string giving the hex sign
nibbles to use for a positive value, a negative value, an unsigned value, and
zero',
+ },
+ {
+ item: 'dfdl:binaryNumberCheckPolicy',
+ snippetString: spacingChar + dfdlPrefix +
'binaryNumberCheckPolicy="${1|strict,lax|}"$0' + afterChar,
+ markdownString: 'Indicates how lenient to be when parsing binary
numbers',
+ },
+ {
+ item: 'dfdl:binaryBooleanTrueRep',
+ snippetString: spacingChar + dfdlPrefix +
'binaryBooleanTrueRep="$1"$0' + afterChar,
+ markdownString: 'A binary xs:unsignedInt gives the representation for
true',
+ },
+ {
+ item: 'dfdl:binaryBooleanFalseRep',
+ snippetString: spacingChar + dfdlPrefix +
'binaryBooleanFalseRep="$1"$0' + afterChar,
+ markdownString: 'A binary xs:unsignedInt gives the representation for
false',
+ },
+ {
+ item: 'dfdl:calendarPattern',
+ snippetString: spacingChar + dfdlPrefix + 'calendarPattern="$1"$0' +
afterChar,
+ markdownString: 'Defines the ICU pattern that describes the format of
the calendar. The pattern defines where the year, month, day, hour, minute,
second, fractional second and time zone components appear',
+ },
{
item: 'dfdl:calendarPatternKind',
- snippetString: dfdlPrefix +
'calendarPatternKind="${1|explicit,implicit|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'calendarPatternKind="${1|explicit,implicit|}"$0' + afterChar,
markdownString: 'The pattern is given by dfdl:calendarPattern explicit
or the pattern is derived from the XML schema date/time type (implicit)',
},
{
- item: "dfdl:documentFinalTerminatorCanBeMissing",
- snippetString: dfdlPrefix +
'documentFinalTerminatorCanBeMissing="${1|yes,no|}"$0',
+ item: 'dfdl:calendarCheckPolicy',
+ snippetString: spacingChar + dfdlPrefix +
'calendarCheckPolicy="${1|strict,lax|}"$0' + afterChar,
+ markdownString: 'Indicates how lenient to be when parsing against the
pattern',
+ },
+ {
+ item: 'dfdl:calendarTimeZone',
+ snippetString: spacingChar + dfdlPrefix + 'calendarTimeZone="$1"$0' +
afterChar,
+ markdownString: 'Provides the time zone that is assumed if no time
zone explicitly occurs in the data',
+ },
+ {
+ item: 'dfdl:calendarObserveDST',
+ snippetString: spacingChar + dfdlPrefix +
'calendarObserveDST="${1|yes,no|}"$0' + afterChar,
+ markdownString: 'Whether the time zone given in dfdl:calendarTimeZone
observes daylight savings time',
+ },
+ {
+ item: 'dfdl:calendarFirstDayOfWeek',
+ snippetString: spacingChar + dfdlPrefix +
'calendarFirstDayOfWeek="${1|Monday,Sunday|}"$0' + afterChar,
+ markdownString: 'The day of the week upon which a new week is
considered to start',
+ },
+ {
+ item: 'dfdl:calendarDaysInFirstWeek',
+ snippetString: spacingChar + dfdlPrefix +
'calendarDaysInFirstWeek="${1|1,2,3,4,5,6,7|}"$0' + afterChar,
+ markdownString: 'Specify the number of days of the new year that must
fall within the first week',
+ },
+ {
+ item: 'dfdl:calendarCenturyStart',
+ snippetString: spacingChar + dfdlPrefix +
'calendarCenturyStart="$1"$0' + afterChar,
+ markdownString: 'specifies the two digits that start a 100-year window
that contains the current year',
+ },
+ {
+ item: 'dfdl:calendarLanguage',
+ snippetString: spacingChar + dfdlPrefix + 'calendarLanguage="$1"$0' +
afterChar,
+ markdownString: 'The language that is used when the pattern produces a
presentation in text',
+ },
+ {
+ item: "dfdl:documentFinalTerminatorCanBeMissing" + afterChar,
+ snippetString: spacingChar + dfdlPrefix +
'documentFinalTerminatorCanBeMissing="${1|yes,no|}"$0',
markdownString: 'Specifies whether the final line can be missing',
},
{
item:'dfdl:emptyValueDelimiterPolicy',
- snippetString: dfdlPrefix +
'emptyValueDelimiterPolicy="${1|initiator,terminator,both,none|}"$0',
+ snippetString: spacingChar + dfdlPrefix +
'emptyValueDelimiterPolicy="${1|initiator,terminator,both,none|}"$0' +
afterChar,
+ markdownString: 'Indicates which of initiator, terminator, both, or
neither must be present when an element in the data stream is empty.',
+ },
+ {
+ item:'dfdl:emptyElementParsePolicy',
+ snippetString: spacingChar + dfdlPrefix +
'emptyElementParsePolicy="${1|treatAsAbsent,treatAsEmpty|}"$0' + afterChar,
markdownString: 'Indicates which of initiator, terminator, both, or
neither must be present when an element in the data stream is empty.',
},
{
item: 'dfdl:escapeSchemeRef',
- snippetString: dfdlPrefix + 'escapeSchemeRef="$1"$0',
+ snippetString: spacingChar + dfdlPrefix + 'escapeSchemeRef="$1"$0' +
afterChar,
markdownString: "Refers to a named escape scheme definition via its
qualified name",
},
+ {
+ item: 'dfdl:escapeKind',
+ snippetString: spacingChar + dfdlPrefix +
'escapeKind="${1|escapeCharacter,escapeBlock|}"$0' + afterChar,
+ markdownString: "The type of escape mechanism defined in the escape
scheme",
+ },
+ {
+ item: 'dfdl:escapeCharacter',
+ snippetString: spacingChar + dfdlPrefix + 'escapeCharacter="$1"$0' +
afterChar,
+ markdownString: "Specifies one character that escapes the subsequent
character",
+ },
+ {
+ item: 'dfdl:escapeBlockStart',
+ snippetString: dfdlPrefix + 'escapeBlockStart="$1"$0',
+ markdownString: "The string of characters that denotes the beginning
of a sequence of characters escaped by a pair of escape strings" + afterChar,
+ },
+ {
+ item: 'dfdl:escapeBlockEnd',
+ snippetString: spacingChar + dfdlPrefix + 'escapeBlockEnd="$1"$0',
+ markdownString: "The string of characters that denotes the end of a
sequence of characters escaped by a pair of escape strings" + afterChar,
+ },
+ {
+ item: 'dfdl:escapeEscapeCharacter',
+ snippetString: spacingChar + dfdlPrefix +
'escapeEscapeCharacter="$1"$0',
+ markdownString: "Specifies one character that escapes an immediately
following dfdl:escapeCharacter" + afterChar,
+ },
+ {
+ item: 'dfdl:extraEscapedCharacters',
+ snippetString: spacingChar + dfdlPrefix +
'extraEscapedCharacters="$1"$0',
+ markdownString: "A whitespace separated list of single characters that
must be escaped in addition to the in-scope delimiters" + afterChar,
+ },
+ {
+ item: 'dfdl:generateEscapeBlock',
+ snippetString: spacingChar + dfdlPrefix +
'generateEscapeBlock="${1|always,whenNeeded|}"$0' + afterChar,
+ markdownString: "The type of escape mechanism defined in the escape
scheme",
+ },
+ {
+ item: 'dfdl:escapeCharacterPolicy',
+ snippetString: spacingChar + dfdlPrefix +
'escapeCharacterPolicy="${1|all,delimiters|}"$0' + afterChar,
+ markdownString: "The type of escape mechanism defined in the escape
scheme",
+ },
{
item: 'testKind',
- snippetString: 'testKind="${1|expression,pattern|}"$0',
+ snippetString: spacingChar + 'testKind="${1|expression,pattern|}"$0' +
afterChar,
markdownString: 'Specifies whether a DFDL expression or DFDL regular
expression pattern is used in the dfdl:assert',
},
{
item: 'test',
- snippetString: dfdlPrefix + 'test="{$1}"$0',
+ snippetString: spacingChar + dfdlPrefix + 'test="{$1}"$0' + afterChar,
markdownString: 'A DFDL expression that evaluates to true or false.',
},
{
item: 'testPattern',
- snippetString: 'testPattern="$1"$0',
+ snippetString: spacingChar + 'testPattern="$1"$0' + afterChar,
markdownString: 'A DFDL regular expression that is applied against the
data stream',
},
{
item: 'message',
- snippetString: 'message="$1"$0',
+ snippetString: spacingChar + 'message="$1"$0' + afterChar,
markdownString: 'Defines text for use in an error message',
},
{
item: 'failureType',
- snippetString:
'failureType="${1|processingError,recoverableError|}"$0',
+ snippetString: spacingChar +
'failureType="${1|processingError,recoverableError|}"$0' + afterChar,
markdownString: 'Specifies the type of failure that occurs when the
dfdl:assert is unsuccessful',
},
],
diff --git a/src/language/providers/intellisense/attributeValueItems.ts
b/src/language/providers/intellisense/attributeValueItems.ts
index 9b28a18..0b2b908 100644
--- a/src/language/providers/intellisense/attributeValueItems.ts
+++ b/src/language/providers/intellisense/attributeValueItems.ts
@@ -30,14 +30,35 @@ export const noChoiceAttributes = [
'outputValueCalc',
'hiddenGroupRef',
'choiceBranchKey',
+ 'textOutputMinLength',
+ 'textStandardDecimalSeparator',
+ 'textStandardGroupingSeparator',
+ 'textZonedSignStyle',
'textNumberRoundingIncrement',
+ 'textBooleanTrueRep',
+ 'textBooleanFalseRep',
+ 'textBooleanJustification',
+ 'textBooleanPadCharacter',
'separator',
'terminator',
'choiceLength',
'fillByte',
'initiator',
'choiceDispatchKey',
+ 'binaryDecimalVirtualPoint',
+ 'binaryPackedSignCodes',
+ 'binaryBooleantrueRep',
+ 'binaryBooleanFalseRep',
+ 'calendarPattern',
+ 'calendarTimeZone',
+ 'calendarCenturyStart',
+ 'calendarLanguage',
'escapeSchemeRef',
+ 'escapeCharacter',
+ 'escapeBlockStart',
+ 'escapeBlockEnd',
+ 'escapeEscapeCharacter',
+ 'extraEscapedCharacters',
'test',
'testPattern',
'message',
@@ -112,6 +133,9 @@ export function attributeValues(
case 'nilValueDelimiterPolicy':
insertSnippet('"${1|initiator,terminator,both,none|}"$0', startPos)
break
+ case 'useNilForDefault':
+ insertSnippet('"${1|yes,no|}"$0', startPos)
+ break
case 'alignment':
insertSnippet('"${1|1,2,implicit|}"$0', startPos)
break
@@ -143,19 +167,19 @@ export function attributeValues(
insertSnippet('"${1|left,right,center|}"$0', startPos)
break
case 'textStandardZeroRep':
- insertSnippet('"0"$0', startPos)
+ insertSnippet('"0$1"$0', startPos)
break
case 'textStandardInfinityRep':
- insertSnippet('"Inf"$0', startPos)
+ insertSnippet('"Inf$1"$0', startPos)
break
case 'textStandardExponentRep':
- insertSnippet('"E"$0', startPos)
+ insertSnippet('"E$1"$0', startPos)
break
case 'textStandardNaNRep':
- insertSnippet('"NaN"$0', startPos)
+ insertSnippet('"NaN$1"$0', startPos)
break
case 'textNumberPattern':
- insertSnippet('"#,##0.###;-#,##0.###"$0', startPos)
+ insertSnippet('"#,##0.###;-#,##0.###$1"$0', startPos)
break
case 'textNumberRep':
insertSnippet('"${1|standard,zoned|}"$0', startPos)
@@ -178,8 +202,11 @@ export function attributeValues(
case 'textOutputMinLength':
insertSnippet('"0"$0', startPos)
break
+ case 'textStandardDecimalSeparator':
+ insertSnippet('"$1"$0', startPos)
+ break
case 'textStandardGroupingSeparator':
- insertSnippet('","$0', startPos)
+ insertSnippet('",$1"$0', startPos)
break
case 'textPadKind':
insertSnippet('"${1|none,padChar|}"$0', startPos)
@@ -187,9 +214,24 @@ export function attributeValues(
case 'textStandardBase':
insertSnippet('"${1|2,8,10,16|}"$0', startPos)
break
+ case 'textZonedSignStyle':
+ insertSnippet('"$1"$0', startPos)
+ break
case 'textTrimKind':
insertSnippet('"${1|none,padChar|}"$0', startPos)
break
+ case 'textBooleanTrueRep':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'textBooleanFalseRep':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'textBooleanJustification':
+ insertSnippet('"${1|left,right,center|}"$0', startPos)
+ break
+ case 'textBooleanPadCharacter':
+ insertSnippet('"$1"$0', startPos)
+ break
case 'leadingSkip':
insertSnippet('"0$1"$0', startPos)
break
@@ -253,18 +295,84 @@ export function attributeValues(
case 'binaryFloatRep':
insertSnippet('"${1|ieee,ibm390Hex|}"$0', startPos)
break
+ case 'binaryDecimalVirtualPoint':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'binaryPackedSignCodes':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'binaryNumberCheckPolicy':
+ insertSnippet('"${1|strict,lax|}"$0', startPos)
+ break
+ case 'dfdl:binaryBooleanTrueRep':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'dfdl:binaryBooleanFalseRep':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'calendarPattern':
+ insertSnippet('"$1"$0', startPos)
+ break
case 'calendarPatternKind':
insertSnippet('"${1|explicit,implicit|}"$0', startPos)
break
+ case 'dfdl:calendarCheckPolicy':
+ insertSnippet('"${1|strict,lax|}"$0', startPos)
+ break
+ case 'dfdl:calendarTimeZone':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'dfdl:calendarObserveDST':
+ insertSnippet('"${1|yes,no|}"$0', startPos)
+ break
+ case 'dfdl:calendarFirstDayOfWeek':
+ insertSnippet('"${1|Monday,Sunday|}"$0', startPos)
+ break
+ case 'dfdl:calendarDaysInFirstWeek':
+ insertSnippet('"${1|1,2,3,4,5,6,7|}"$0', startPos)
+ break
+ case 'dfdl:calendarCenturyStart':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'dfdl:calendarLanguage':
+ insertSnippet('"$1"$0', startPos)
+ break
case 'documentFinalTerminatorCanBeMissing':
insertSnippet('"${1|yes,no|}"$0', startPos)
break
case 'emptyValueDelimiterPolicy':
insertSnippet('"${1|initiator,terminator,both,none|}"$0', startPos)
break
+ case 'emptyElementParsePolicy':
+ insertSnippet('"${1|treatAsAbsent,treatAsEmpty|}"$0', startPos)
+ break
case 'escapeSchemeRef':
insertSnippet('"$1"$0', startPos)
break
+ case 'escapeKind':
+ insertSnippet('"${1|escapeCharacter,escapeBlock|}"$0', startPos)
+ break
+ case ':escapeCharacter':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'escapeBlockStart':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'escapeBlockEnd':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'escapeEscapeCharacter':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'extraEscapedCharacters':
+ insertSnippet('"$1"$0', startPos)
+ break
+ case 'generateEscapeBlock':
+ insertSnippet('"${1|always,whenNeeded|}"$0', startPos)
+ break
+ case 'escapeCharacterPolicy':
+ insertSnippet('"${1|all,delimiters|}"$0', startPos)
+ break
case 'testKind':
insertSnippet('"${1|expression,pattern|}"$0', startPos)
break
diff --git a/src/language/providers/intellisense/commonItems.ts
b/src/language/providers/intellisense/commonItems.ts
index c748412..b7d1f44 100644
--- a/src/language/providers/intellisense/commonItems.ts
+++ b/src/language/providers/intellisense/commonItems.ts
@@ -23,7 +23,7 @@ export const commonCompletion = (additionalItems) => {
item: 'type',
// use the "xs:" prefix for primitive types to differentiate them from
custom simple types
snippetString:
'type="${1|xs:string,xs:decimal,xs:float,xs:double,xs:integer,xs:nonNegativeInteger,xs:int,xs:unsignedInt,xs:short,xs:unsignedShort,xs:long,xs:unsignedLong,xs:byte,xs:unsignedByte,xs:hexBinary,xs:boolean'
+ additionalItems + '|}"$0',
- markdownString: 'an attribute which specifies the type of a
simply-typed element',
+ markdownString: 'The name of a built in data type, or the name of a
simpleType or complexType element defined in this schema',
},
],
}
diff --git a/src/language/providers/intellisense/elementItems.ts
b/src/language/providers/intellisense/elementItems.ts
index db6e52a..cf13b6e 100644
--- a/src/language/providers/intellisense/elementItems.ts
+++ b/src/language/providers/intellisense/elementItems.ts
@@ -23,10 +23,6 @@ export const elementCompletion = (definedVariables,
nsPrefix) => {
item: 'xml version',
snippetString: '<?xml version="1.0" encoding="UTF-8"?>\n$0',
},
-/* {
- item: nsPrefix + 'schema',
- snippetString: '<${1|\0,xs:,xsd:|}$2' + 'schema
xmlns:xs="http://www.w3.org/2001/xmlSchema"\n\t\txmlns:dfdl="http://www.ogf.org/dfdl/dfdl-1.0/"\n\t\txmlns:daf="urn:ogf:dfdl:2013:imp:daffodil.apache.org:2018:ext"\n\t\txmlns:fn="http:/www.w3.org/2005/xpath-functions"\n\t\t
elementFormDefault="unqualified">\n$0\n</' + nsPrefix + 'schema>',
- },*/
{
item: nsPrefix + 'schema',
snippetString: '<${1|\0,xs:,xsd:|}$2' + 'schema
xmlns:xs="http://www.w3.org/2001/xmlSchema"\n\t\txmlns:dfdl="http://www.ogf.org/dfdl/dfdl-1.0/"\n\t\txmlns:daf="urn:ogf:dfdl:2013:imp:daffodil.apache.org:2018:ext"\n\t\txmlns:fn="http:/www.w3.org/2005/xpath-functions"\nelementFormDefault="unqualified"$0',
@@ -63,7 +59,7 @@ export const elementCompletion = (definedVariables, nsPrefix)
=> {
},
{
item: 'dfdl:format',
- snippetString: '<dfdl:format $0/>',
+ snippetString: '<dfdl:format $0',
markdownString: 'Defines the physical data format properties for
multiple DFDL schema constructs',
},
{
@@ -104,6 +100,11 @@ export const elementCompletion = (definedVariables,
nsPrefix) => {
snippetString: '<' + nsPrefix + 'choice',
markdownString: 'Define group of mutually exclusive elements that
resolve points of uncertainty that cannot be resolved by speculative parsing',
},
+ {
+ item: 'dfdl:newVariableInstance',
+ snippetString: '<dfdl:newVariableInstance ref="$1"$0',
+ markdownString: 'Defines the name, type, and optional default value
for the variable'
+ },
{
item: 'dfdl:defineVariable',
snippetString: '<dfdl:defineVariable name="$1"$0',
@@ -124,6 +125,11 @@ export const elementCompletion = (definedVariables,
nsPrefix) => {
snippetString: '<dfdl:defineEscapeScheme name=$1
>\n\t$0,/dfdl:defineEscapeScheme>',
markdownString: 'Defines a named, reusable escapeScheme',
},
+ {
+ item: 'dfdl:escapeScheme',
+ snippetString: '<dfdl:escapeScheme $0',
+ markdownString: 'Allows a common set of properties to be defined that
can be reused',
+ },
{
item: 'dfdl:simpleType',
snippetString: '<dfdl:simpleType $1/>$0',
@@ -132,7 +138,27 @@ export const elementCompletion = (definedVariables,
nsPrefix) => {
{
item: 'dfdl:element',
snippetString: '<dfdl:element $1/>$0',
- markdownString: 'Defines the physical data format properties of an
xs:element and xs:element reference',
+ markdownString: 'Defines the physical data format properties of an
xs:element',
+ },
+ {
+ item: 'dfdl:sequence',
+ snippetString: '<dfdl:sequence $1/>$0',
+ markdownString: 'Defines the physical data format properties of an
xs:sequence group',
+ },
+ {
+ item: 'dfdl:group',
+ snippetString: '<dfdl:group $1/>$0',
+ markdownString: 'Defines the physical data format properties of an
xs:group reference',
+ },
+ {
+ item: 'dfdl:choice',
+ snippetString: '<dfdl:choice $1/>$0',
+ markdownString: 'Defines the physical data format properties of an
xs:choice group',
+ },
+ {
+ item: 'dfdl:property',
+ snippetString: '<dfdl:property name="$1">\n\t$2\n</dfdl:property>$0',
+ markdownString: 'Used in the syntax of format annotations',
},
{
item: 'restriction',
@@ -160,6 +186,40 @@ export const elementCompletion = (definedVariables,
nsPrefix) => {
snippetString: '<' + nsPrefix + 'maxExclusive value="$1"/>$0',
markdownString: 'Used to check the validity of an element'
},
+ {
+ item: 'pattern',
+ snippetString: '<' + nsPrefix + 'pattern value="$1"/>$0',
+ markdownString: 'Used to derive new simple types by specifying a
regular expression against which values of the type are compared'
+ },
+ {
+ item: 'totalDigits',
+ snippetString: '<' + nsPrefix + 'totalDigits value="$1"/>$0',
+ markdownString: 'Indicates the maximum allowed value for the number of
digits'
+ },
+ {
+ item: 'fractionDigits',
+ snippetString: '<' + nsPrefix + 'fractionDigits value="$1"/>$0',
+ markdownString: 'Indicates the maximum number of digits in the
fractional part'
+ },
+ {
+ item: 'enumeration',
+ snippetString: '<' + nsPrefix + 'enumeration value="$1"/>$0',
+ markdownString: 'Used to restrict a datatype to a finite set of values'
+ },
+ {
+ item: 'include',
+ snippetString: '<' + nsPrefix + 'include "$1"/>$0',
+ markdownString: 'Used to add all the components of an included schema'
+ },
+ {
+ item: 'documentation',
+ snippetString: '<' + nsPrefix +
'documentation>\n\t$1\n</documentation>$0'
+ },
+ {
+ item: 'import',
+ snippetString: '<' + nsPrefix + 'import "$1"/>$0',
+ markdownString: 'Used to add all the components of an included schema'
+ },
{
item: '<[CDATA[]]>',
snippetString: '<[CDATA[$1]]>$0',
diff --git a/src/language/providers/utils.ts b/src/language/providers/utils.ts
index 9dd15c9..f01613d 100644
--- a/src/language/providers/utils.ts
+++ b/src/language/providers/utils.ts
@@ -35,8 +35,11 @@ const items = [
'discriminator',
'defineFormat',
'format',
+ 'newVariableInstance',
'defineVariable',
'setVariable',
+ 'defineEscapeScheme',
+ 'escapeScheme',
'dfdl:element',
'dfdl:simpleType',
'restriction',
@@ -274,7 +277,8 @@ export function getItemPrefix(item: string, nsPrefix:
string) {
item === 'discriminator' ||
item === 'defineFormat' ||
item === 'format' ||
- item.includes('Variable')
+ item.includes('Variable') ||
+ item.includes('scape')
) {
itemPrefix = 'dfdl:'
}
diff --git a/src/tests/suite/language/items.test.ts
b/src/tests/suite/language/items.test.ts
index 3f85722..c771404 100644
--- a/src/tests/suite/language/items.test.ts
+++ b/src/tests/suite/language/items.test.ts
@@ -30,7 +30,6 @@ suite('Items Test Suite', () => {
'group ref',
'dfdl:assert',
'dfdl:discriminator',
- 'dfdl:hiddenGroupRef',
'dfdl:format',
'annotation',
'appinfo',
@@ -40,17 +39,30 @@ suite('Items Test Suite', () => {
'simpleType name=',
'sequence',
'choice',
+ 'dfdl:newVariableInstance',
'dfdl:defineVariable',
'dfdl:setVariable',
'dfdl:defineFormat',
'dfdl:defineEscapeScheme',
+ 'dfdl:escapeScheme',
'dfdl:simpleType',
'dfdl:element',
+ 'dfdl:sequence',
+ 'dfdl:group',
+ 'dfdl:choice',
+ 'dfdl:property',
'restriction',
'minInclusive',
'minExclusive',
'maxInclusive',
'maxExclusive',
+ 'pattern',
+ 'totalDigits',
+ 'fractionDigits',
+ 'enumeration',
+ 'include',
+ 'documentation',
+ 'import',
'<[CDATA[]]>',
'<![CDATA[]]>',
'{}',
@@ -74,6 +86,7 @@ suite('Items Test Suite', () => {
'dfdl:nilKind',
'dfdl:nilValue',
'dfdl:nilValueDelimiterPolicy',
+ 'dfdl:useNilForDefault',
'dfdl:alignment',
'dfdl:lengthUnits',
'dfdl:lengthPattern',
@@ -84,21 +97,30 @@ suite('Items Test Suite', () => {
'dfdl:choiceBranchKey',
'dfdl:representation',
'dfdl:textStringJustification',
+ 'dfdl:textStringPadCharacter',
'dfdl:textStandardZeroRep',
'dfdl:textStandardInfinityRep',
'dfdl:textStandardExponentRep',
'dfdl:textStandardNaNRep',
'dfdl:textNumberPattern',
+ 'dfdl:decimalSigned',
'dfdl:textNumberRep',
+ 'dfdl:textNumberJustification',
'dfdl:textNumberRoundingMode',
'dfdl:textNumberRoundingIncrement',
'dfdl:textNumberRounding',
'dfdl:textNumberCheckPolicy',
'dfdl:textOutputMinLength',
+ 'dfdl:textStandardDecimalSeparator',
'dfdl:textStandardGroupingSeparator',
'dfdl:textPadKind',
'dfdl:textStandardBase',
+ 'dfdl:textZonedSignStyle',
'dfdl:textTrimKind',
+ 'dfdl:textBooleanTrueRep',
+ 'dfdl:textBooleanFalseRep',
+ 'dfdl:textBooleanJustification',
+ 'dfdl:textBooleanPadCharacter',
'dfdl:leadingSkip',
'dfdl:trailingSkip',
'dfdl:truncateSpecifiedLengthString',
@@ -119,10 +141,32 @@ suite('Items Test Suite', () => {
'dfdl:binaryNumberRep',
'dfdl:floating',
'dfdl:binaryFloatRep',
+ 'dfdl:binaryDecimalVirtualPoint',
+ 'dfdl:binaryPackedSignCodes',
+ 'dfdl:binaryNumberCheckPolicy',
+ 'dfdl:binaryBooleanTrueRep',
+ 'dfdl:binaryBooleanFalseRep',
+ 'dfdl:calendarPattern',
'dfdl:calendarPatternKind',
+ 'dfdl:calendarCheckPolicy',
+ 'dfdl:calendarTimeZone',
+ 'dfdl:calendarObserveDST',
+ 'dfdl:calendarFirstDayOfWeek',
+ 'dfdl:calendarDaysInFirstWeek',
+ 'dfdl:calendarCenturyStart',
+ 'dfdl:calendarLanguage',
'dfdl:documentFinalTerminatorCanBeMissing',
'dfdl:emptyValueDelimiterPolicy',
+ 'dfdl:emptyElementParsePolicy',
'dfdl:escapeSchemeRef',
+ 'dfdl:escapeKind',
+ 'dfdl:escapeCharacter',
+ 'dfdl:escapeBlockStart',
+ 'dfdl:escapeBlockEnd',
+ 'dfdl:escapeEscapeCharacter',
+ 'dfdl:extraEscapedCharacters',
+ 'dfdl:generateEscapeBlock',
+ 'dfdl:escapeCharacterPolicy',
'testKind',
'test',
'testPattern',
@@ -143,7 +187,7 @@ suite('Items Test Suite', () => {
})
test('all attributeItems available', async () => {
- attributeCompletion('dfdl:').items.forEach((item) => {
+ attributeCompletion('', '', 'dfdl:', '', '').items.forEach((item) => {
assert.strictEqual(expectedAttributeItems.includes(item.item), true)
})
})
