3178 lines
107 KiB
TypeScript
3178 lines
107 KiB
TypeScript
import {
|
|
CompoundDashNumberNormalizerFn,
|
|
CompoundDashRomanNumberNormalizerFn,
|
|
CompoundDotNumberNormalizerFn,
|
|
ConsumedFolderMatchingRegexp,
|
|
consumeFolderByRegexpExpression,
|
|
convertPlainStringToRegex,
|
|
detectSortingSymbols,
|
|
escapeRegexUnsafeCharacters,
|
|
extractSortingSymbol,
|
|
hasMoreThanOneSortingSymbol,
|
|
NumberNormalizerFn,
|
|
RegexpUsedAs,
|
|
RomanNumberNormalizerFn,
|
|
SortingSpecProcessor
|
|
} from "./sorting-spec-processor"
|
|
import {
|
|
CustomSortGroupType,
|
|
CustomSortOrder,
|
|
CustomSortSpec,
|
|
IdentityNormalizerFn
|
|
} from "./custom-sort-types";
|
|
import {
|
|
FolderMatchingRegexp,
|
|
FolderMatchingTreeNode
|
|
} from "./folder-matching-rules";
|
|
|
|
const txtInputExampleA: string = `
|
|
order-asc: a-z
|
|
/ ...
|
|
/: ...
|
|
|
|
target-folder: tricky folder
|
|
/
|
|
/:
|
|
|
|
:::: tricky folder 2
|
|
/: with-metadata:
|
|
< a-z by-metadata: Some-dedicated-field
|
|
with-metadata: Pages
|
|
> a-z by-metadata:
|
|
/: with-icon:
|
|
with-icon: RiClock24
|
|
starred:
|
|
/:files starred:
|
|
/folders starred:
|
|
|
|
:::: folder of bookmarks
|
|
< by-bookmarks-order
|
|
/: bookmarked:
|
|
< by-bookmarks-order
|
|
/ Abc
|
|
> by-bookmarks-order
|
|
|
|
:::: Conceptual model
|
|
/: Entities
|
|
%
|
|
|
|
target-folder: /
|
|
/: Con...
|
|
/
|
|
> advanced modified
|
|
/:
|
|
< modified
|
|
/: Ref...
|
|
/: Att...ch
|
|
sort...spec
|
|
/:. sortspec.md
|
|
|
|
target-folder: Sandbox
|
|
> modified
|
|
/: adfsasda
|
|
/ sdsadasdsa
|
|
> a-z
|
|
/folders fdsfdsfdsfs
|
|
> created
|
|
|
|
target-folder: Abcd efgh ijk
|
|
> a-z
|
|
Plain text spec bla bla bla (matches files and folders)...
|
|
/:. files only matching
|
|
> a-z
|
|
/ folders only matching
|
|
< a-z
|
|
some-file (or folder)
|
|
/:. sort....md
|
|
Trailer item
|
|
|
|
:::: References
|
|
:::: Same rules as for References
|
|
Recently...
|
|
`;
|
|
const txtInputExampleAVerbose: string = `
|
|
order-asc: a-z
|
|
/folders ...
|
|
/:files ...
|
|
|
|
target-folder: tricky folder
|
|
/folders
|
|
/:files
|
|
|
|
target-folder: tricky folder 2
|
|
/:files with-metadata:
|
|
< a-z by-metadata: Some-dedicated-field
|
|
% with-metadata: Pages
|
|
> a-z by-metadata:
|
|
/:files with-icon:
|
|
/folders:files with-icon: RiClock24
|
|
/folders:files starred:
|
|
/:files starred:
|
|
/folders starred:
|
|
|
|
target-folder: folder of bookmarks
|
|
order-asc: by-bookmarks-order
|
|
/:files bookmarked:
|
|
order-asc: by-bookmarks-order
|
|
/folders Abc
|
|
order-desc: by-bookmarks-order
|
|
|
|
:::: Conceptual model
|
|
/:files Entities
|
|
%
|
|
|
|
target-folder: /
|
|
/:files Con...
|
|
/folders
|
|
> advanced modified
|
|
/:files
|
|
< modified
|
|
/:files Ref...
|
|
/:files Att...ch
|
|
% sort...spec
|
|
/:files. sortspec.md
|
|
|
|
target-folder: Sandbox
|
|
> modified
|
|
/:files adfsasda
|
|
/folders sdsadasdsa
|
|
> a-z
|
|
/ fdsfdsfdsfs
|
|
> created
|
|
|
|
target-folder: Abcd efgh ijk
|
|
\> a-z
|
|
Plain text spec bla bla bla (matches files and folders)...
|
|
/:files. files only matching
|
|
> a-z
|
|
/folders folders only matching
|
|
\< a-z
|
|
% some-file (or folder)
|
|
/:files. sort....md
|
|
% Trailer item
|
|
|
|
target-folder: References
|
|
target-folder: Same rules as for References
|
|
% Recently...
|
|
`;
|
|
|
|
const expectedSortSpecsExampleA: { [key: string]: CustomSortSpec } = {
|
|
"mock-folder": {
|
|
defaultOrder: CustomSortOrder.alphabetical,
|
|
groups: [{
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.MatchAll
|
|
}, {
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.MatchAll
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
targetFoldersPaths: ['mock-folder'],
|
|
outsidersGroupIdx: 2
|
|
},
|
|
"tricky folder": {
|
|
groups: [{
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersFilesGroupIdx: 1,
|
|
outsidersFoldersGroupIdx: 0,
|
|
targetFoldersPaths: ['tricky folder']
|
|
},
|
|
"tricky folder 2": {
|
|
groups: [{
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.HasMetadataField,
|
|
withMetadataFieldName: 'sort-index-value',
|
|
order: CustomSortOrder.byMetadataFieldAlphabetical,
|
|
byMetadataField: 'Some-dedicated-field',
|
|
}, {
|
|
type: CustomSortGroupType.HasMetadataField,
|
|
withMetadataFieldName: 'Pages',
|
|
order: CustomSortOrder.byMetadataFieldAlphabeticalReverse
|
|
}, {
|
|
type: CustomSortGroupType.HasIcon,
|
|
filesOnly: true
|
|
}, {
|
|
type: CustomSortGroupType.HasIcon,
|
|
iconName: 'RiClock24'
|
|
}, {
|
|
type: CustomSortGroupType.StarredOnly
|
|
}, {
|
|
type: CustomSortGroupType.StarredOnly,
|
|
filesOnly: true
|
|
}, {
|
|
type: CustomSortGroupType.StarredOnly,
|
|
foldersOnly: true
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 7,
|
|
targetFoldersPaths: [
|
|
'tricky folder 2'
|
|
]
|
|
},
|
|
"folder of bookmarks": {
|
|
defaultOrder: CustomSortOrder.byBookmarkOrder,
|
|
groups: [
|
|
{
|
|
filesOnly: true,
|
|
order: CustomSortOrder.byBookmarkOrder,
|
|
type: CustomSortGroupType.BookmarkedOnly
|
|
},
|
|
{
|
|
exactText: "Abc",
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.byBookmarkOrderReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},
|
|
{
|
|
type: CustomSortGroupType.Outsiders
|
|
}
|
|
],
|
|
outsidersGroupIdx: 2,
|
|
targetFoldersPaths: [
|
|
"folder of bookmarks"
|
|
]
|
|
},
|
|
"Conceptual model": {
|
|
groups: [{
|
|
exactText: "Entities",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 1,
|
|
targetFoldersPaths: ['Conceptual model']
|
|
},
|
|
"/": {
|
|
groups: [{
|
|
exactPrefix: "Con",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
filesOnly: true,
|
|
order: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
exactPrefix: "Ref",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactPrefix: "Att",
|
|
exactSuffix: "ch",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactHeadAndTail
|
|
}, {
|
|
exactPrefix: "sort",
|
|
exactSuffix: "spec",
|
|
type: CustomSortGroupType.ExactHeadAndTail
|
|
}, {
|
|
exactText: "sortspec.md",
|
|
filesOnly: true,
|
|
matchFilenameWithExt: true,
|
|
type: CustomSortGroupType.ExactName
|
|
}],
|
|
outsidersFilesGroupIdx: 2,
|
|
outsidersFoldersGroupIdx: 1,
|
|
targetFoldersPaths: ['/']
|
|
},
|
|
"Sandbox": {
|
|
defaultOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
groups: [{
|
|
exactText: "adfsasda",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "sdsadasdsa",
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "fdsfdsfdsfs",
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.byCreatedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 3,
|
|
targetFoldersPaths: ['Sandbox']
|
|
},
|
|
"Abcd efgh ijk": {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
groups: [{
|
|
exactPrefix: "Plain text spec bla bla bla (matches files and folders)",
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactText: "files only matching",
|
|
filesOnly: true,
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
matchFilenameWithExt: true,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "folders only matching",
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.alphabetical,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "some-file (or folder)",
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactPrefix: "sort",
|
|
exactSuffix: ".md",
|
|
filesOnly: true,
|
|
matchFilenameWithExt: true,
|
|
type: CustomSortGroupType.ExactHeadAndTail
|
|
}, {
|
|
exactText: "Trailer item",
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 6,
|
|
targetFoldersPaths: ['Abcd efgh ijk']
|
|
},
|
|
"References": {
|
|
groups: [{
|
|
exactPrefix: "Recently",
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 1,
|
|
targetFoldersPaths: ['References', 'Same rules as for References']
|
|
},
|
|
"Same rules as for References": {
|
|
groups: [{
|
|
exactPrefix: "Recently",
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 1,
|
|
targetFoldersPaths: ['References', 'Same rules as for References']
|
|
}
|
|
}
|
|
|
|
const expectedSortSpecsExampleSortingSymbols: { [key: string]: CustomSortSpec } = {
|
|
"mock-folder": {
|
|
groups: [{
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix,
|
|
regexPrefix: {
|
|
regex: /^Chapter *(\d+(?:\.\d+)*) /i,
|
|
normalizerFn: CompoundDotNumberNormalizerFn
|
|
}
|
|
}, {
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactSuffix,
|
|
regexSuffix: {
|
|
regex: /section *([MDCLXVI]+(?:-[MDCLXVI]+)*)\.$/i,
|
|
normalizerFn: CompoundDashRomanNumberNormalizerFn
|
|
}
|
|
}, {
|
|
type: CustomSortGroupType.ExactName,
|
|
regexPrefix: {
|
|
regex: /^Appendix *(\d+(?:-\d+)*) \(attachments\)$/i,
|
|
normalizerFn: CompoundDashNumberNormalizerFn
|
|
}
|
|
}, {
|
|
type: CustomSortGroupType.ExactHeadAndTail,
|
|
exactSuffix: ' works?',
|
|
regexPrefix: {
|
|
regex: /^Plain syntax *([MDCLXVI]+) /i,
|
|
normalizerFn: RomanNumberNormalizerFn
|
|
}
|
|
}, {
|
|
type: CustomSortGroupType.ExactHeadAndTail,
|
|
exactPrefix: 'And this kind of',
|
|
regexSuffix: {
|
|
regex: / *(\d+)plain syntax\?\?\?$/i,
|
|
normalizerFn: NumberNormalizerFn
|
|
}
|
|
}, {
|
|
type: CustomSortGroupType.ExactName,
|
|
regexPrefix: {
|
|
regex: /^Here goes ASCII word ([a-zA-Z]+)$/i,
|
|
normalizerFn: IdentityNormalizerFn
|
|
}
|
|
}, {
|
|
type: CustomSortGroupType.ExactName,
|
|
regexPrefix: {
|
|
regex: /^(\p{Letter}+)\. is for any modern language word$/iu,
|
|
normalizerFn: IdentityNormalizerFn
|
|
}
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
targetFoldersPaths: ['mock-folder'],
|
|
outsidersGroupIdx: 7
|
|
}
|
|
}
|
|
|
|
const txtInputExampleSortingSymbols: string = `
|
|
/folders Chapter \\.d+ ...
|
|
/:files ...section \\-r+.
|
|
% Appendix \\-d+ (attachments)
|
|
Plain syntax\\R+ ... works?
|
|
And this kind of... \\D+plain syntax???
|
|
Here goes ASCII word \\a+
|
|
\\A+. is for any modern language word
|
|
`
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should generate correct SortSpecs (complex example A)', () => {
|
|
const inputTxtArr: Array<string> = txtInputExampleA.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsExampleA)
|
|
})
|
|
it('should generate correct SortSpecs (complex example A verbose)', () => {
|
|
const inputTxtArr: Array<string> = txtInputExampleAVerbose.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsExampleA)
|
|
})
|
|
it('should generate correct SortSpecs (example with sorting symbols)', () => {
|
|
const inputTxtArr: Array<string> = txtInputExampleSortingSymbols.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsExampleSortingSymbols)
|
|
})
|
|
})
|
|
|
|
const txtInputNotDuplicatedSortSpec: string = `
|
|
target-folder: AAA
|
|
> A-Z
|
|
target-folder: BBB
|
|
% Whatever ...
|
|
`
|
|
|
|
const expectedSortSpecsNotDuplicatedSortSpec: { [key: string]: CustomSortSpec } = {
|
|
"AAA": {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['AAA']
|
|
},
|
|
"BBB": {
|
|
groups: [{
|
|
exactPrefix: "Whatever ",
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 1,
|
|
targetFoldersPaths: ['BBB']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should not duplicate spec if former target-folder had some attribute specified', () => {
|
|
const inputTxtArr: Array<string> = txtInputNotDuplicatedSortSpec.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsNotDuplicatedSortSpec)
|
|
})
|
|
})
|
|
|
|
const txtInputStandardObsidianSortAttr: string = `
|
|
target-folder: AAA
|
|
sorting: standard
|
|
/ Some folder
|
|
< standard
|
|
`
|
|
|
|
const expectedSortSpecForObsidianStandardSorting: { [key: string]: CustomSortSpec } = {
|
|
"AAA": {
|
|
defaultOrder: CustomSortOrder.standardObsidian,
|
|
groups: [{
|
|
exactText: 'Some folder',
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.standardObsidian,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 1,
|
|
targetFoldersPaths: ['AAA']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize the standard Obsidian sorting attribute for a folder', () => {
|
|
const inputTxtArr: Array<string> = txtInputStandardObsidianSortAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForObsidianStandardSorting)
|
|
})
|
|
})
|
|
|
|
const txtInputFilesOrFoldersPreferred: string = `
|
|
target-folder: AAA
|
|
< a-z, files-first
|
|
subitems1...
|
|
> folders-first, true a-z.
|
|
subitems2...
|
|
< created, folders-first
|
|
`
|
|
|
|
const expectedSortSpecForFilesOrFoldersPreferred: { [key: string]: CustomSortSpec } = {
|
|
"AAA": {
|
|
defaultOrder: CustomSortOrder.alphabetical,
|
|
defaultSecondaryOrder: CustomSortOrder.fileFirst,
|
|
groups: [{
|
|
exactPrefix: 'subitems1',
|
|
order: CustomSortOrder.folderFirst,
|
|
secondaryOrder: CustomSortOrder.trueAlphabeticalWithFileExt,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
},{
|
|
exactPrefix: 'subitems2',
|
|
order: CustomSortOrder.byCreatedTime,
|
|
secondaryOrder: CustomSortOrder.folderFirst,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 2,
|
|
targetFoldersPaths: ['AAA']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize the files / folders preferred as a primary and secondary orders', () => {
|
|
const inputTxtArr: Array<string> = txtInputFilesOrFoldersPreferred.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForFilesOrFoldersPreferred)
|
|
})
|
|
})
|
|
|
|
const txtInputThreeDotsCases: string = `
|
|
target-folder: AAA
|
|
...
|
|
....
|
|
// Only in the below scenario the / is treated as empty-separator and swallowed
|
|
./...
|
|
// Below tricky and not obvious cases
|
|
../...
|
|
.../..
|
|
../...S
|
|
S.../..
|
|
S../...S
|
|
`
|
|
|
|
const expectedSortSpecForThreeDotsCases: { [key: string]: CustomSortSpec } = {
|
|
"AAA": {
|
|
groups: [{
|
|
type: CustomSortGroupType.MatchAll
|
|
},{
|
|
exactSuffix: '.',
|
|
type: CustomSortGroupType.ExactSuffix
|
|
},{
|
|
exactPrefix: '.',
|
|
type: CustomSortGroupType.ExactPrefix
|
|
},{
|
|
exactPrefix: '..',
|
|
type: CustomSortGroupType.ExactPrefix
|
|
},{
|
|
exactSuffix: '/..',
|
|
type: CustomSortGroupType.ExactSuffix
|
|
},{
|
|
exactPrefix: '..',
|
|
exactSuffix: 'S',
|
|
type: CustomSortGroupType.ExactHeadAndTail
|
|
},{
|
|
exactPrefix: 'S',
|
|
exactSuffix: '/..',
|
|
type: CustomSortGroupType.ExactHeadAndTail
|
|
},{
|
|
exactPrefix: 'S..',
|
|
exactSuffix: 'S',
|
|
type: CustomSortGroupType.ExactHeadAndTail
|
|
},{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 8,
|
|
targetFoldersPaths: ['AAA']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should correctly handle some of three-dots scenarios', () => {
|
|
const inputTxtArr: Array<string> = txtInputThreeDotsCases.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForThreeDotsCases)
|
|
})
|
|
})
|
|
|
|
const txtInputTrueAlphabeticalSortAttr: string = `
|
|
target-folder: True Alpha
|
|
< true a-z
|
|
target-folder: True Alpha Rev
|
|
> true a-z
|
|
target-folder: True Alpha withExt
|
|
< true a-z.
|
|
target-folder: True Alpha Rev withExt
|
|
> true a-z.
|
|
target-folder: by-meta True Alpha
|
|
< true a-z by-metadata:
|
|
target-folder: by-meta True Alpha Rev
|
|
> true a-z by-metadata: Some-attr
|
|
`
|
|
|
|
const expectedSortSpecForTrueAlphabeticalSorting: { [key: string]: CustomSortSpec } = {
|
|
"True Alpha": {
|
|
defaultOrder: CustomSortOrder.trueAlphabetical,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['True Alpha']
|
|
},
|
|
"True Alpha Rev": {
|
|
defaultOrder: CustomSortOrder.trueAlphabeticalReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['True Alpha Rev']
|
|
},
|
|
"True Alpha withExt": {
|
|
defaultOrder: CustomSortOrder.trueAlphabeticalWithFileExt,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['True Alpha withExt']
|
|
},
|
|
"True Alpha Rev withExt": {
|
|
defaultOrder: CustomSortOrder.trueAlphabeticalReverseWithFileExt,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['True Alpha Rev withExt']
|
|
},
|
|
"by-meta True Alpha": {
|
|
defaultOrder: CustomSortOrder.byMetadataFieldTrueAlphabetical,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['by-meta True Alpha']
|
|
},
|
|
"by-meta True Alpha Rev": {
|
|
defaultOrder: CustomSortOrder.byMetadataFieldTrueAlphabeticalReverse,
|
|
byMetadataField: 'Some-attr',
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['by-meta True Alpha Rev']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize the true alphabetical (and reverse) sorting attribute for a folder', () => {
|
|
const inputTxtArr: Array<string> = txtInputTrueAlphabeticalSortAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForTrueAlphabeticalSorting)
|
|
})
|
|
})
|
|
|
|
const txtInputSimplistic1: string = `
|
|
target-folder: /*
|
|
/:files
|
|
/folders
|
|
`
|
|
|
|
const expectedSortSpecForSimplistic1: { [key: string]: CustomSortSpec } = {
|
|
"/": {
|
|
groups: [{
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersFilesGroupIdx: 0,
|
|
outsidersFoldersGroupIdx: 1,
|
|
targetFoldersPaths: ['/*']
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForSimplistic1 = {
|
|
"matchAll": {
|
|
groups: [{
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersFilesGroupIdx: 0,
|
|
outsidersFoldersGroupIdx: 1,
|
|
targetFoldersPaths: ['/*']
|
|
},
|
|
"subtree": {}
|
|
}
|
|
|
|
const txtInputSimplistic2: string = `
|
|
target-folder: /
|
|
/:files
|
|
/folders
|
|
`
|
|
|
|
const expectedSortSpecForSimplistic2: { [key: string]: CustomSortSpec } = {
|
|
"/": {
|
|
groups: [{
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersFilesGroupIdx: 0,
|
|
outsidersFoldersGroupIdx: 1,
|
|
targetFoldersPaths: ['/']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize the simplistic sorting spec to put files first (wildcard /* rule)', () => {
|
|
const inputTxtArr: Array<string> = txtInputSimplistic1.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForSimplistic1)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForSimplistic1)
|
|
})
|
|
it('should recognize the simplistic sorting spec to put files first (direct / rule)', () => {
|
|
const inputTxtArr: Array<string> = txtInputSimplistic2.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForSimplistic2)
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
const txtInputItemsToHideWithDupsSortSpec: string = `
|
|
target-folder: AAA
|
|
/--hide: SomeFileToHide.md
|
|
--% SomeFileToHide.md
|
|
--% SomeFolderToHide
|
|
/--hide: SomeFolderToHide
|
|
--% HideItRegardlessFileOrFolder
|
|
`
|
|
|
|
const expectedHiddenItemsSortSpec: { [key: string]: CustomSortSpec } = {
|
|
"AAA": {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
itemsToHide: new Set(['SomeFileToHide.md', 'SomeFolderToHide', 'HideItRegardlessFileOrFolder']),
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['AAA']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor bonus experimental feature', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should correctly parse list of items to hide', () => {
|
|
const inputTxtArr: Array<string> = txtInputItemsToHideWithDupsSortSpec.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
// REMARK: be careful with examining Set object
|
|
expect(result?.sortSpecByPath).toEqual(expectedHiddenItemsSortSpec)
|
|
})
|
|
})
|
|
|
|
const txtInputItemsReadmeExample1Spec: string = `
|
|
// Less verbose versions of the spec,
|
|
// I know that at root level there will only folders matching
|
|
// the below names, so I can skip the /folders prefix
|
|
// I know there are no other root level folders and files
|
|
// so no need to specify order for them
|
|
target-folder: /
|
|
Projects
|
|
Areas
|
|
Responsibilities
|
|
Archive
|
|
/--hide: sortspec.md
|
|
`
|
|
|
|
const expectedReadmeExample1SortSpec: { [key: string]: CustomSortSpec } = {
|
|
"/": {
|
|
groups: [{
|
|
exactText: 'Projects',
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: 'Areas',
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: 'Responsibilities',
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: 'Archive',
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
itemsToHide: new Set(['sortspec.md']),
|
|
outsidersGroupIdx: 4,
|
|
targetFoldersPaths: ['/']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor - README.md examples', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should correctly parse example 1', () => {
|
|
const inputTxtArr: Array<string> = txtInputItemsReadmeExample1Spec.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
// REMARK: be careful with examining Set object
|
|
expect(result?.sortSpecByPath).toEqual(expectedReadmeExample1SortSpec)
|
|
})
|
|
})
|
|
|
|
const txtInputEmptySpecOnlyTargetFolder: string = `
|
|
target-folder: BBB
|
|
`
|
|
|
|
const expectedSortSpecsOnlyTargetFolder: { [key: string]: CustomSortSpec } = {
|
|
"BBB": {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['BBB']
|
|
}
|
|
}
|
|
|
|
const txtInputTargetFolderAsDot: string = `
|
|
// Let me introduce a comment here ;-) to ensure it is ignored
|
|
target-folder: .
|
|
target-folder: CCC
|
|
target-folder: ./sub
|
|
target-folder: ./*
|
|
target-folder: ./...
|
|
//target-folder: ./.../
|
|
// This comment should be ignored as well
|
|
`
|
|
|
|
const expectedSortSpecToBeMultiplied = {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder', 'CCC', 'mock-folder/sub', "mock-folder/*", "mock-folder/..."]
|
|
}
|
|
|
|
const expectedSortSpecsTargetFolderAsDot: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': expectedSortSpecToBeMultiplied,
|
|
'CCC': expectedSortSpecToBeMultiplied,
|
|
'mock-folder/sub': expectedSortSpecToBeMultiplied
|
|
}
|
|
|
|
describe('SortingSpecProcessor edge case', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize empty spec containing only target folder', () => {
|
|
const inputTxtArr: Array<string> = txtInputEmptySpecOnlyTargetFolder.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsOnlyTargetFolder)
|
|
})
|
|
it('should recognize and correctly replace dot as the target folder', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderAsDot.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsTargetFolderAsDot)
|
|
expect(result?.sortSpecByWildcard).not.toBeNull()
|
|
})
|
|
})
|
|
|
|
const txtInputTargetFolderByName: string = `
|
|
target-folder: name: TheName
|
|
< a-z
|
|
`
|
|
|
|
const txtInputTargetFolderWithRegex: string = `
|
|
> advanced modified
|
|
target-folder: name: TheName
|
|
< a-z
|
|
target-folder: regexp: r1
|
|
target-folder: regexp: /!!: r2*
|
|
target-folder: regexp: for-name: r3.{2-3}$
|
|
target-folder: regexp: for-name: /!: r4\\d
|
|
target-folder: regexp: for-name: /!!: ^r5[^[]+
|
|
target-folder: regexp: for-name: /!!!: ^r6/+$
|
|
target-folder: regexp: debug: r7 +
|
|
target-folder: regexp: for-name: debug: r8 (aa|bb|cc)
|
|
target-folder: regexp: for-name: /!!!: debug: r9 [abc]+
|
|
target-folder: regexp: /!: debug: ^r10 /[^/]/.+$
|
|
`
|
|
|
|
const expectedSortSpecTargetFolderRegexAndName1 = {
|
|
defaultOrder: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
|
|
const expectedSortSpecTargetFolderByName = {
|
|
defaultOrder: CustomSortOrder.alphabetical,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['name: TheName']
|
|
}
|
|
|
|
const expectedSortSpecsTargetFolderByPathInRegexTestCase: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': expectedSortSpecTargetFolderRegexAndName1
|
|
}
|
|
|
|
const expectedSortSpecsTargetFolderByName: { [key: string]: CustomSortSpec } = {
|
|
'TheName': expectedSortSpecTargetFolderByName
|
|
}
|
|
|
|
const expectedSortSpecForRegexpTextCase = {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: [
|
|
"regexp: r1",
|
|
"regexp: /!!: r2*",
|
|
"regexp: for-name: r3.{2-3}$",
|
|
"regexp: for-name: /!: r4\\d",
|
|
"regexp: for-name: /!!: ^r5[^[]+",
|
|
"regexp: for-name: /!!!: ^r6/+$",
|
|
"regexp: debug: r7 +",
|
|
"regexp: for-name: debug: r8 (aa|bb|cc)",
|
|
"regexp: for-name: /!!!: debug: r9 [abc]+",
|
|
"regexp: /!: debug: ^r10 /[^/]/.+$"
|
|
]
|
|
}
|
|
|
|
const expectedTargetFolderRegexpArr: Array<FolderMatchingRegexp<CustomSortSpec>> = [
|
|
{
|
|
regexp: /r9 [abc]+/,
|
|
againstName: true,
|
|
priority: 3,
|
|
logMatches: true,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /^r6\/+$/,
|
|
againstName: true,
|
|
priority: 3,
|
|
logMatches: false,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /^r5[^[]+/,
|
|
againstName: true,
|
|
priority: 2,
|
|
logMatches: false,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /r2*/,
|
|
againstName: false,
|
|
priority: 2,
|
|
logMatches: false,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /^r10 \/[^/]\/.+$/,
|
|
againstName: false,
|
|
priority: 1,
|
|
logMatches: true,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /r4\d/,
|
|
againstName: true,
|
|
priority: 1,
|
|
logMatches: false,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /r8 (aa|bb|cc)/,
|
|
againstName: true,
|
|
priority: 0,
|
|
logMatches: true,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /r7 +/,
|
|
againstName: false,
|
|
priority: 0,
|
|
logMatches: true,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /r3.{2-3}$/,
|
|
againstName: true,
|
|
priority: 0,
|
|
logMatches: false,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
},
|
|
{
|
|
regexp: /r1/,
|
|
againstName: false,
|
|
priority: 0,
|
|
logMatches: false,
|
|
sortingSpec: expectedSortSpecForRegexpTextCase
|
|
}
|
|
]
|
|
|
|
describe('SortingSpecProcessor target-folder by name and regex', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should correctly handle the by-name only target-folder', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderByName.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toBeUndefined()
|
|
expect(result?.sortSpecByName).toEqual(expectedSortSpecsTargetFolderByName)
|
|
expect(result?.sortSpecByWildcard).not.toBeNull()
|
|
})
|
|
it('should recognize and correctly parse target folder by name with and w/o regexp variants', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderWithRegex.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsTargetFolderByPathInRegexTestCase)
|
|
expect(result?.sortSpecByName).toEqual(expectedSortSpecsTargetFolderByName)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual({subtree: {}})
|
|
expect(result?.sortSpecByWildcard?.regexps).toEqual(expectedTargetFolderRegexpArr)
|
|
})
|
|
})
|
|
|
|
const NOPRIO = 0
|
|
const PRIO1 = 1
|
|
const PRIO2 = 2
|
|
const PRIO3 = 3
|
|
|
|
const consumedTargetFolderRegexp: Array<ConsumedFolderMatchingRegexp> = [
|
|
{
|
|
regexp: /r4\d/,
|
|
againstName: true,
|
|
priority: undefined,
|
|
log: true
|
|
}, {
|
|
regexp: /r4\d/,
|
|
againstName: true,
|
|
priority: PRIO1,
|
|
log: true
|
|
}, {
|
|
regexp: /r4\d/,
|
|
againstName: true,
|
|
priority: PRIO2,
|
|
log: true
|
|
}, {
|
|
regexp: /r4\d/,
|
|
againstName: true,
|
|
priority: PRIO3,
|
|
log: true
|
|
},
|
|
]
|
|
|
|
describe( 'consumeFolderByRegexpExpression', () => {
|
|
// and accept priority in any order
|
|
// the last one is in effect
|
|
// and accept multiple
|
|
it.each([
|
|
// Plain cases
|
|
['for-name: /!: debug: r4\\d', PRIO1],
|
|
['for-name: /!: debug: r4\\d', PRIO1],
|
|
['/!!: for-name: debug: r4\\d', PRIO2],
|
|
['/!: debug: for-name: r4\\d', PRIO1],
|
|
['debug: for-name: /!!!: r4\\d', PRIO3],
|
|
['debug: /!: for-name: r4\\d', PRIO1],
|
|
// Cases with duplication of same
|
|
['for-name: for-name: /!: debug: r4\\d', PRIO1],
|
|
['for-name: /!: /!: debug: debug: r4\\d', PRIO1],
|
|
['/!!: for-name: /!!: debug: r4\\d', PRIO2],
|
|
['/!: debug: debug: for-name: r4\\d', PRIO1],
|
|
['debug: for-name: /!!!:/!!!: r4\\d', PRIO3],
|
|
['debug: /!: for-name: /!: r4\\d', PRIO1],
|
|
// Cases with duplication of different priority
|
|
['debug: /!!!: for-name: /!: r4\\d', PRIO1],
|
|
['debug: /!: for-name: /!!: r4\\d', PRIO2],
|
|
['debug: /!: for-name: /!!: /!!!: /!: /!!!: r4\\d', PRIO3],
|
|
])('should recognize all modifiers in >%s< of priority %s', (regexpExpr: string, prio: number) => {
|
|
const result: ConsumedFolderMatchingRegexp = consumeFolderByRegexpExpression(regexpExpr)
|
|
expect(result).toEqual(consumedTargetFolderRegexp[prio])
|
|
})
|
|
})
|
|
|
|
const txtInputPriorityGroups1: string = `
|
|
target-folder: /
|
|
/:files
|
|
/folders
|
|
/! /:files Fi...
|
|
/!! /folders Fo...
|
|
/!!! ...def!
|
|
Plain text
|
|
/! % Anything
|
|
`
|
|
|
|
const txtInputPriorityGroups2: string = `
|
|
target-folder: /
|
|
/! /:files Fi...
|
|
/!! /folders Fo...
|
|
/!!! ...def!
|
|
/! Anything
|
|
`
|
|
|
|
const expectedSortSpecForPriorityGroups1: { [key: string]: CustomSortSpec } = {
|
|
"/": {
|
|
groups: [{
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
exactPrefix: "Fi",
|
|
filesOnly: true,
|
|
priority: 1,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactPrefix: "Fo",
|
|
foldersOnly: true,
|
|
priority: 2,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactSuffix: "def!",
|
|
priority: 3,
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
exactText: "Plain text",
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "Anything",
|
|
priority: 1,
|
|
type: CustomSortGroupType.ExactName
|
|
}],
|
|
outsidersFilesGroupIdx: 0,
|
|
outsidersFoldersGroupIdx: 1,
|
|
targetFoldersPaths: ['/'],
|
|
priorityOrder: [4,3,2,6,5]
|
|
}
|
|
}
|
|
|
|
const expectedSortSpecForPriorityGroups2: { [key: string]: CustomSortSpec } = {
|
|
"/": {
|
|
groups: [{
|
|
exactPrefix: "Fi",
|
|
filesOnly: true,
|
|
priority: 1,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactPrefix: "Fo",
|
|
foldersOnly: true,
|
|
priority: 2,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactSuffix: "def!",
|
|
priority: 3,
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
exactText: "Anything",
|
|
priority: 1,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 4,
|
|
targetFoldersPaths: ['/'],
|
|
priorityOrder: [2,1,0,3]
|
|
}
|
|
}
|
|
|
|
const expectedSortSpecForPriorityAndCombineGroups: { [key: string]: CustomSortSpec } = {
|
|
"/": {
|
|
groups: [{
|
|
combineWithIdx: 0,
|
|
exactPrefix: "Fi",
|
|
filesOnly: true,
|
|
priority: 1,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
combineWithIdx: 0,
|
|
exactPrefix: "Fo",
|
|
foldersOnly: true,
|
|
priority: 2,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactSuffix: "def!",
|
|
priority: 3,
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
exactText: "Anything",
|
|
priority: 1,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 4,
|
|
targetFoldersPaths: ['/'],
|
|
priorityOrder: [2,1,0,3]
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize the sorting groups with priority example 1', () => {
|
|
const inputTxtArr: Array<string> = txtInputPriorityGroups1.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForPriorityGroups1)
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should recognize the sorting groups with priority example 2', () => {
|
|
const inputTxtArr: Array<string> = txtInputPriorityGroups2.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForPriorityGroups2)
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should recognize the combine and priority prefixes in any order example 1', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: /
|
|
/! /+ /:files Fi...
|
|
/!! /+ /folders Fo...
|
|
/!!! ...def!
|
|
/! Anything
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForPriorityAndCombineGroups)
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should recognize the combine and priority prefixes in any order example 2', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: /
|
|
/+ /! /:files Fi...
|
|
/+ /!! /folders Fo...
|
|
/!!! ...def!
|
|
/! Anything
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForPriorityAndCombineGroups)
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should accept the combine operator in single line only', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: /
|
|
/+ /:files Fi...
|
|
/folders Fo...
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"/": {
|
|
groups: [{
|
|
combineWithIdx: 0,
|
|
exactPrefix: "Fi",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactPrefix: "Fo",
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 2,
|
|
targetFoldersPaths: ['/']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should correctly parse combine operator, apply explicit sorting to combined groups', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: /
|
|
Nothing
|
|
> a-z
|
|
/+ /:files Fi...
|
|
/+ /folders Fo...
|
|
... Separator
|
|
/+ Abc...
|
|
/+ ...Def
|
|
/+ ...
|
|
> modified
|
|
Unreachable line
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"/": {
|
|
groups: [{
|
|
exactText: "Nothing",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
combineWithIdx: 1,
|
|
exactPrefix: "Fi",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
combineWithIdx: 1,
|
|
exactPrefix: "Fo",
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactSuffix: " Separator",
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
combineWithIdx: 4,
|
|
exactPrefix: "Abc",
|
|
order: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
combineWithIdx: 4,
|
|
exactSuffix: "Def",
|
|
order: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
combineWithIdx: 4,
|
|
order: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.MatchAll
|
|
}, {
|
|
exactText: "Unreachable line",
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 8,
|
|
targetFoldersPaths: ['/']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should correctly parse combine operator, apply explicit complex sorting to combined groups', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: /
|
|
< created, a-z desc by-metadata: someMdataFld // intentionally folder-level, to confirm no inheritance folder->groups
|
|
Nothing
|
|
> a-z, a-z
|
|
/+ /:files Fi...
|
|
/+ /folders Fo...
|
|
... Separator
|
|
/+ Abc...
|
|
/+ ...Def
|
|
/+ ...
|
|
< a-z by-metadata: abc-def, true a-z asc by-metadata: ghi-jkl1
|
|
Unreachable line
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"/": {
|
|
defaultOrder: CustomSortOrder.byCreatedTime,
|
|
defaultSecondaryOrder: CustomSortOrder.byMetadataFieldAlphabeticalReverse,
|
|
byMetadataFieldSecondary: "someMdataFld",
|
|
groups: [{
|
|
exactText: "Nothing",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.alphabetical,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
combineWithIdx: 1,
|
|
exactPrefix: "Fi",
|
|
filesOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
combineWithIdx: 1,
|
|
exactPrefix: "Fo",
|
|
foldersOnly: true,
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
exactSuffix: " Separator",
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
combineWithIdx: 4,
|
|
exactPrefix: "Abc",
|
|
order: CustomSortOrder.byMetadataFieldAlphabetical,
|
|
byMetadataField: "abc-def",
|
|
secondaryOrder: CustomSortOrder.byMetadataFieldTrueAlphabetical,
|
|
byMetadataFieldSecondary: "ghi-jkl1",
|
|
type: CustomSortGroupType.ExactPrefix
|
|
}, {
|
|
combineWithIdx: 4,
|
|
exactSuffix: "Def",
|
|
order: CustomSortOrder.byMetadataFieldAlphabetical,
|
|
byMetadataField: "abc-def",
|
|
secondaryOrder: CustomSortOrder.byMetadataFieldTrueAlphabetical,
|
|
byMetadataFieldSecondary: "ghi-jkl1",
|
|
type: CustomSortGroupType.ExactSuffix
|
|
}, {
|
|
combineWithIdx: 4,
|
|
order: CustomSortOrder.byMetadataFieldAlphabetical,
|
|
byMetadataField: "abc-def",
|
|
secondaryOrder: CustomSortOrder.byMetadataFieldTrueAlphabetical,
|
|
byMetadataFieldSecondary: "ghi-jkl1",
|
|
type: CustomSortGroupType.MatchAll
|
|
}, {
|
|
exactText: "Unreachable line",
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 8,
|
|
targetFoldersPaths: ['/']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
const txtInputStandardSortingVariants1: string = `
|
|
sorting: standard, sorting: ui selected
|
|
/folders:files
|
|
> ui selected desc, standard asc
|
|
`
|
|
|
|
const txtInputStandardSortingVariants2: string = `
|
|
order-desc: standard desc, < ui selected asc
|
|
/folders:files
|
|
sorting: ui selected asc, order-desc: standard desc
|
|
`
|
|
|
|
const expectedSortSpecsStandardSortingVariants: { [key: string]: CustomSortSpec } = {
|
|
"mock-folder": {
|
|
defaultOrder: CustomSortOrder.standardObsidian,
|
|
defaultSecondaryOrder: CustomSortOrder.standardObsidian,
|
|
groups: [{
|
|
order: CustomSortOrder.standardObsidian,
|
|
secondaryOrder: CustomSortOrder.standardObsidian,
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
}
|
|
|
|
describe('standard sorting (aka Obsidian UI selected)', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize variants of the syntax', () => {
|
|
const inputTxtArr: Array<string> = txtInputStandardSortingVariants1.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsStandardSortingVariants)
|
|
})
|
|
it('ignores any direction specified in any way', () => {
|
|
const inputTxtArr: Array<string> = txtInputStandardSortingVariants2.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecsStandardSortingVariants)
|
|
})
|
|
})
|
|
|
|
describe('comments and higher level specs in sorting order spec', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('can occur at the end of line', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
> created // An inline comment in sorting order specification
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"mock-folder": {
|
|
defaultOrder: CustomSortOrder.byCreatedTimeReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('inline always span to the end of line', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
> created //, > modified <-- he he, the // take it all
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"mock-folder": {
|
|
defaultOrder: CustomSortOrder.byCreatedTimeReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('ignore 3rd+ sorting level specs', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
> created, < modified, a-z, < true a-z
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"mock-folder": {
|
|
defaultOrder: CustomSortOrder.byCreatedTimeReverse,
|
|
defaultSecondaryOrder: CustomSortOrder.byModifiedTime,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('multi-level sorting', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should accept direction lexemes in prefix and postfix notations, various variants', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
a pre
|
|
order-asc: true a-z, order-asc: modified
|
|
a pre 2
|
|
order-asc: true a-z., < modified
|
|
a post 1
|
|
order-asc: true a-z, modified order-asc
|
|
a post 2
|
|
order-asc: true a-z, modified asc
|
|
a post
|
|
order-asc: true a-z, modified <
|
|
a none
|
|
order-asc: true a-z, modified
|
|
a unspecified
|
|
order-asc: true a-z, sorting: modified
|
|
a dbl specified
|
|
order-asc: true a-z asc, < modified <
|
|
d pre
|
|
order-desc: true a-z, order-desc: modified
|
|
d pre 2
|
|
order-desc: true a-z, > modified
|
|
d post 1
|
|
order-desc: true a-z, modified order-desc
|
|
d post 2
|
|
order-desc: true a-z, modified desc
|
|
d post
|
|
order-desc: true a-z, modified >
|
|
d none
|
|
order-desc: true a-z., modified
|
|
d unspecified
|
|
order-desc: true a-z, sorting: modified
|
|
d dbl specified
|
|
order-desc: true a-z desc, > modified >
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"mock-folder": {
|
|
groups: [{
|
|
exactText: "a pre",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a pre 2",
|
|
order: CustomSortOrder.trueAlphabeticalWithFileExt,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a post 1",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a post 2",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a post",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a none",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a unspecified",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "a dbl specified",
|
|
order: CustomSortOrder.trueAlphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d pre",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d pre 2",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d post 1",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d post 2",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d post",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d none",
|
|
order: CustomSortOrder.trueAlphabeticalReverseWithFileExt,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d unspecified",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "d dbl specified",
|
|
order: CustomSortOrder.trueAlphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 16,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
it('should correctly parse legacy examples', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
a c a
|
|
< a-z, created asc
|
|
a c d
|
|
< a-z, created desc
|
|
a ac a
|
|
< a-z., advanced created asc
|
|
a ac d
|
|
< a-z, advanced created desc
|
|
a m a
|
|
< a-z, modified asc
|
|
a m d
|
|
< a-z, modified desc
|
|
a am a
|
|
< a-z, advanced modified asc
|
|
a am d
|
|
< a-z, advanced modified desc
|
|
d c a
|
|
> a-z., created asc
|
|
d c d
|
|
> a-z, created desc
|
|
d ac a
|
|
> a-z, advanced created asc
|
|
d ac d
|
|
> a-z, advanced created desc
|
|
d m a
|
|
> a-z, modified asc
|
|
d m d
|
|
> a-z, modified desc
|
|
d am a
|
|
> a-z, advanced modified asc
|
|
d am d
|
|
> a-z, advanced modified desc
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
"mock-folder": {
|
|
groups: [{
|
|
exactText: "a c a",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byCreatedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "a c d",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byCreatedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a ac a",
|
|
order: CustomSortOrder.alphabeticalWithFileExt,
|
|
secondaryOrder: CustomSortOrder.byCreatedTimeAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a ac d",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byCreatedTimeReverseAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a m a",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a m d",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a am a",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "a am d",
|
|
order: CustomSortOrder.alphabetical,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d c a",
|
|
order: CustomSortOrder.alphabeticalReverseWithFileExt,
|
|
secondaryOrder: CustomSortOrder.byCreatedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
}, {
|
|
exactText: "d c d",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byCreatedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d ac a",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byCreatedTimeAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d ac d",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byCreatedTimeReverseAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d m a",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTime,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d m d",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverse,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d am a",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
exactText: "d am d",
|
|
order: CustomSortOrder.alphabeticalReverse,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
type: CustomSortGroupType.ExactName
|
|
},{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 16,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('the sorting: prefix', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should default to ascending, if not specified (primary only)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: a-z
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.alphabetical,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
})
|
|
it('should default to ascending, if not specified (primary and secondary levels)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: true a-z, sorting: advanced modified
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.trueAlphabetical,
|
|
defaultSecondaryOrder: CustomSortOrder.byModifiedTimeAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
})
|
|
it('should use postfix-specified direction (primary only)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: a-z desc
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
})
|
|
it('should use postfix-specified direction (primary and secondary levels)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: true a-z order-desc, sorting: advanced modified desc
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.trueAlphabeticalReverse,
|
|
defaultSecondaryOrder: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
})
|
|
it('secondary should not inherit direction from primary', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/folders:files.
|
|
sorting: a-z. desc, sorting: advanced modified
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual({
|
|
'mock-folder': {
|
|
groups: [{
|
|
order: CustomSortOrder.alphabeticalReverseWithFileExt,
|
|
secondaryOrder: CustomSortOrder.byModifiedTimeAdvanced,
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
})
|
|
})
|
|
})
|
|
|
|
const txtInputTargetFolderMultiSpecA: string = `
|
|
target-folder: .
|
|
< a-z
|
|
target-folder: ./*
|
|
> a-z
|
|
target-folder: ./.../
|
|
< modified
|
|
`
|
|
|
|
const txtInputTargetFolderMultiSpecB: string = `
|
|
target-folder: ./*
|
|
> a-z
|
|
target-folder: ./.../
|
|
< modified
|
|
target-folder: .
|
|
< a-z
|
|
`
|
|
|
|
const expectedSortSpecForMultiSpecAandB: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.alphabetical,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder']
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecAandB: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchAll: {
|
|
"defaultOrder": CustomSortOrder.alphabeticalReverse,
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/*"]
|
|
},
|
|
matchChildren: {
|
|
"defaultOrder": CustomSortOrder.byModifiedTime,
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/.../"]
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const txtInputTargetFolderMultiSpecC: string = `
|
|
target-folder: ./*
|
|
> a-z
|
|
target-folder: ./.../
|
|
`
|
|
|
|
const expectedSortSpecForMultiSpecC: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder/.../']
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecC: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchAll: {
|
|
"defaultOrder": CustomSortOrder.alphabeticalReverse,
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/*"]
|
|
},
|
|
matchChildren: {
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/.../"]
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const txtInputTargetFolderMultiSpecD: string = `
|
|
target-folder: ./*
|
|
`
|
|
|
|
const txtInputTargetFolderMultiSpecD_implicitCase: string = `
|
|
// typically implicit specs come context-free, no notion of current folder, that's why using explicit target-folder path
|
|
target-folder: mock-folder/*
|
|
// Reverse order to distinguish between implicit and explicit spec
|
|
> a-z
|
|
`
|
|
|
|
const expectedSortSpecForMultiSpecD: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder/*']
|
|
}
|
|
}
|
|
|
|
const expectedSortSpecForMultiSpecD_implicitCase: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder/*'],
|
|
implicit: true
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecD: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchAll: {
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/*"]
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecD_implicitCase: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchAll: {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/*"],
|
|
implicit: true
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const txtInputTargetFolderMultiSpecE: string = `
|
|
target-folder: mock-folder/...
|
|
`
|
|
|
|
const txtInputTargetFolderMultiSpecE_implicitCase: string = `
|
|
// typically implicit specs come context-free, no notion of current folder, that's why using explicit target-folder path
|
|
target-folder: mock-folder/...
|
|
// Reverse order to distinguish between implicit and explicit spec
|
|
> a-z
|
|
`
|
|
|
|
const expectedSortSpecForMultiSpecE: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder/...']
|
|
}
|
|
}
|
|
|
|
const expectedSortSpecForMultiSpecE_implicitCase: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder/...'],
|
|
implicit: true
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecE: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchChildren: {
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/..."]
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecE_implicitCase: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchChildren: {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/..."],
|
|
implicit: true
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const expectedWildcardMatchingTreeForMultiSpecDplusE_implicitCase: FolderMatchingTreeNode<CustomSortSpec> = {
|
|
subtree: {
|
|
"mock-folder": {
|
|
matchAll: {
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/*"]
|
|
},
|
|
matchChildren: {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
"groups": [{
|
|
"type": CustomSortGroupType.Outsiders
|
|
}],
|
|
"outsidersGroupIdx": 0,
|
|
"targetFoldersPaths": ["mock-folder/..."],
|
|
implicit: true
|
|
},
|
|
name: "mock-folder",
|
|
subtree: {}
|
|
}
|
|
}
|
|
}
|
|
|
|
const txtInputTargetFolderMultiSpecF_implicitCase: string = `
|
|
// typically implicit specs come context-free, no notion of current folder, that's why using explicit target-folder path
|
|
target-folder: mock-folder
|
|
// Reverse order to distinguish between implicit and explicit spec
|
|
> a-z
|
|
`
|
|
|
|
const expectedSortSpecForMultiSpecF_implicitCase: { [key: string]: CustomSortSpec } = {
|
|
'mock-folder': {
|
|
defaultOrder: CustomSortOrder.alphabeticalReverse,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['mock-folder'],
|
|
implicit: true
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor path wildcard priorities', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case A', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderMultiSpecA.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecAandB)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecAandB)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case B', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderMultiSpecB.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecAandB)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecAandB)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case C', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderMultiSpecC.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecC)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecC)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case D', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderMultiSpecD.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecD)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecD)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case D - with implicit spec', () => {
|
|
const inputTxtArrImplicit: Array<string> = txtInputTargetFolderMultiSpecD_implicitCase.split('\n')
|
|
const resultImplicit = processor.parseSortSpecFromText(inputTxtArrImplicit, 'implicit ignored param', 'implicit ignored param', null, true)
|
|
expect(resultImplicit?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecD_implicitCase)
|
|
expect(resultImplicit?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecD_implicitCase)
|
|
const inputTxtArrExplicit: Array<string> = txtInputTargetFolderMultiSpecD.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArrExplicit, 'mock-folder', 'custom-name-note.md', resultImplicit)
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecD)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecD)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case E', () => {
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderMultiSpecE.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecE)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecE)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case E - with implicit spec', () => {
|
|
const inputTxtArrImplicit: Array<string> = txtInputTargetFolderMultiSpecE_implicitCase.split('\n')
|
|
const resultImplicit = processor.parseSortSpecFromText(inputTxtArrImplicit, 'implicit ignored param', 'implicit ignored param', null, true)
|
|
expect(resultImplicit?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecE_implicitCase)
|
|
expect(resultImplicit?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecE_implicitCase)
|
|
const inputTxtArrExplicit: Array<string> = txtInputTargetFolderMultiSpecE.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArrExplicit, 'mock-folder', 'custom-name-note.md', resultImplicit)
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecE)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecE)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, mixed case D+E - with implicit spec, which looses all', () => {
|
|
const inputTxtArrImplicit: Array<string> = txtInputTargetFolderMultiSpecE_implicitCase.split('\n')
|
|
const resultImplicit = processor.parseSortSpecFromText(inputTxtArrImplicit, 'implicit ignored param', 'implicit ignored param', null, true)
|
|
expect(resultImplicit?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecE_implicitCase)
|
|
expect(resultImplicit?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecE_implicitCase)
|
|
const inputTxtArrExplicit: Array<string> = txtInputTargetFolderMultiSpecD.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArrExplicit, 'mock-folder', 'custom-name-note.md', resultImplicit)
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecD)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecDplusE_implicitCase)
|
|
})
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, mixed case E+F => implicit by name', () => {
|
|
const inputTxtArrImplicit: Array<string> = txtInputTargetFolderMultiSpecF_implicitCase.split('\n')
|
|
const resultImplicit = processor.parseSortSpecFromText(inputTxtArrImplicit, 'implicit ignored param', 'implicit ignored param', null, true)
|
|
expect(resultImplicit?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecF_implicitCase)
|
|
expect(resultImplicit?.sortSpecByWildcard?.tree).toBeUndefined()
|
|
const inputTxtArrExplicit: Array<string> = txtInputTargetFolderMultiSpecE.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArrExplicit, 'mock-folder', 'custom-name-note.md', resultImplicit)
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForMultiSpecF_implicitCase)
|
|
expect(result?.sortSpecByWildcard?.tree).toEqual(expectedWildcardMatchingTreeForMultiSpecE)
|
|
})
|
|
})
|
|
|
|
const txtInputAdvancedFolderDateSortingMethods: string = `
|
|
target-folder: A
|
|
< advanced modified
|
|
target-folder: B
|
|
> advanced modified
|
|
target-folder: C
|
|
< advanced created
|
|
target-folder: D
|
|
> advanced created
|
|
target-folder: AA
|
|
/folders
|
|
< advanced modified
|
|
/:files
|
|
> advanced modified
|
|
/folders Archive...
|
|
< advanced created
|
|
/:files Archive...
|
|
> advanced created
|
|
`
|
|
|
|
const expectedSortSpecForAdvancedFolderDateSortingMethods: { [key: string]: CustomSortSpec } = {
|
|
'A': {
|
|
defaultOrder: CustomSortOrder.byModifiedTimeAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['A']
|
|
},
|
|
'B': {
|
|
defaultOrder: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['B']
|
|
},
|
|
'C': {
|
|
defaultOrder: CustomSortOrder.byCreatedTimeAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['C']
|
|
},
|
|
'D': {
|
|
defaultOrder: CustomSortOrder.byCreatedTimeReverseAdvanced,
|
|
groups: [{
|
|
type: CustomSortGroupType.Outsiders
|
|
}],
|
|
outsidersGroupIdx: 0,
|
|
targetFoldersPaths: ['D']
|
|
},
|
|
'AA': {
|
|
groups: [{
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.byModifiedTimeAdvanced,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
filesOnly: true,
|
|
order: CustomSortOrder.byModifiedTimeReverseAdvanced,
|
|
type: CustomSortGroupType.Outsiders
|
|
}, {
|
|
exactPrefix: 'Archive',
|
|
foldersOnly: true,
|
|
order: CustomSortOrder.byCreatedTimeAdvanced,
|
|
type: 3
|
|
}, {
|
|
exactPrefix: 'Archive',
|
|
filesOnly: true,
|
|
order: CustomSortOrder.byCreatedTimeReverseAdvanced,
|
|
type: 3
|
|
}],
|
|
outsidersFilesGroupIdx: 1,
|
|
outsidersFoldersGroupIdx: 0,
|
|
targetFoldersPaths: ['AA']
|
|
}
|
|
}
|
|
|
|
describe('SortingSpecProcessor advanced folder-date based sorting methods', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should not raise error for multiple spec for the same path and choose correct spec, case A', () => {
|
|
const inputTxtArr: Array<string> = txtInputAdvancedFolderDateSortingMethods.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result?.sortSpecByPath).toEqual(expectedSortSpecForAdvancedFolderDateSortingMethods)
|
|
expect(result?.sortSpecByWildcard).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
const errorsLogger = jest.fn();
|
|
|
|
const ERR_PREFIX = 'Sorting specification problem:'
|
|
const ERR_SUFFIX = '---encountered in sorting spec in file mock-folder/custom-name-note.md'
|
|
const ERR_SUFFIX_IN_LINE = (n: number) => `---encountered in line ${n} of sorting spec in file mock-folder/custom-name-note.md`
|
|
const ERR_LINE_TXT = (txt: string) => `Content of problematic line: "${txt}"`
|
|
|
|
const txtInputErrorDupTargetFolder: string = `
|
|
target-folder: AAA
|
|
:::: AAA
|
|
> Modified
|
|
`
|
|
|
|
const txtInputErrorMissingSpaceTargetFolderAttr: string = `
|
|
target-folder:AAA
|
|
:::: AAA
|
|
> Modified
|
|
`
|
|
const txtInputErrorEmptyValueOfTargetFolderAttr: string = `
|
|
target-folder:
|
|
:::: AAA
|
|
> Modified
|
|
`
|
|
// There is a trailing space character in the first line
|
|
const txtInputErrorSpaceAsValueOfTargetFolderAttr: string = `
|
|
TARGET-FOLDER:
|
|
:::: AAA
|
|
> Modified
|
|
`
|
|
const txtInputErrorSpaceAsValueOfAscendingAttr: string = `
|
|
ORDER-ASC:
|
|
`
|
|
const txtInputErrorInvalidValueOfDescendingAttr: string = `
|
|
/folders
|
|
> definitely not correct
|
|
`
|
|
const txtInputErrorNoSpaceDescendingAttr: string = `
|
|
/:files Chapter ...
|
|
Order-DESC:MODIFIED
|
|
`
|
|
const txtInputErrorItemToHideWithNoValue: string = `
|
|
target-folder: AAA
|
|
--%
|
|
`
|
|
const txtInputErrorTooManyNumericSortSymbols: string = `
|
|
% Chapter\\R+ ... page\\d+
|
|
`
|
|
|
|
/* No longer applicable
|
|
const txtInputErrorNestedStandardObsidianSortAttr: string = `
|
|
target-folder: AAA
|
|
/ Some folder
|
|
sorting: standard
|
|
`
|
|
*/
|
|
|
|
const txtInputErrorPriorityEmptyFilePattern: string = `
|
|
/!! /:
|
|
`
|
|
|
|
const txtInputErrorPriorityEmptyFolderPattern: string = `
|
|
/!!! /
|
|
`
|
|
|
|
const txtInputErrorPriorityEmptyPattern: string = `
|
|
/! %
|
|
`
|
|
|
|
const txtInputErrorUnsupportedOrderForByMetadata: string = `
|
|
< modified by-metadata:
|
|
`
|
|
|
|
const txtInputEmptySpec: string = ``
|
|
const txtInputOnlyCommentsSpec: string = `
|
|
// Some comment
|
|
|
|
// Another comment below empty line
|
|
`
|
|
|
|
describe('SortingSpecProcessor error detection and reporting', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor(errorsLogger);
|
|
errorsLogger.mockReset()
|
|
});
|
|
it('should recognize error: target folder name duplicated (edge case)', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorDupTargetFolder.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenCalledWith(`${ERR_PREFIX} 2:DuplicateSortSpecForSameFolder Duplicate sorting spec for folder AAA ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize error: no space before target folder name ', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorMissingSpaceTargetFolderAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1, `${ERR_PREFIX} 6:NoSpaceBetweenAttributeAndValue Space required after attribute name "target-folder:" ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger
|
|
).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('target-folder:AAA'))
|
|
})
|
|
it('should recognize error: no value for target folder attr (immediate endline)', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorEmptyValueOfTargetFolderAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 5:MissingAttributeValue Attribute "target-folder:" requires a value to follow ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('target-folder:'))
|
|
})
|
|
it('should recognize error: no value for target folder attr (space only)', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorSpaceAsValueOfTargetFolderAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 5:MissingAttributeValue Invalid target folder specification: "TARGET-FOLDER:" requires a value to follow ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('TARGET-FOLDER: '))
|
|
})
|
|
it('should recognize error: no value for ascending sorting attr (space only)', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorSpaceAsValueOfAscendingAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 5:MissingAttributeValue Invalid sorting order: "ORDER-ASC:" requires a value to follow ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('ORDER-ASC: '))
|
|
})
|
|
it('should recognize error: invalid value for descending sorting attr (space only)', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorInvalidValueOfDescendingAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Primary sorting order contains unrecognized text: >>> definitely not correct <<< ${ERR_SUFFIX_IN_LINE(3)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT(' > definitely not correct'))
|
|
})
|
|
it('should recognize error: no space before value for descending sorting attr (space only)', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorNoSpaceDescendingAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 6:NoSpaceBetweenAttributeAndValue Space required after attribute name "Order-DESC:" ${ERR_SUFFIX_IN_LINE(3)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('Order-DESC:MODIFIED'))
|
|
})
|
|
it('should recognize error: item to hide requires exact name with ext', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorItemToHideWithNoValue.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 11:ItemToHideExactNameWithExtRequired Exact name with ext of file or folders to hide is required ${ERR_SUFFIX_IN_LINE(3)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('--%'))
|
|
})
|
|
it('should recognize error: too many numeric sorting indicators in a line', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorTooManyNumericSortSymbols.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 9:TooManySortingSymbols Maximum one sorting symbol allowed per line ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('% Chapter\\R+ ... page\\d+ '))
|
|
})
|
|
/* Problem no longer applicable
|
|
it('should recognize error: nested standard obsidian sorting attribute', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorNestedStandardObsidianSortAttr.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 14:StandardObsidianSortAllowedOnlyAtFolderLevel The standard Obsidian sort order is only allowed at a folder level (not nested syntax) ${ERR_SUFFIX_IN_LINE(4)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT(' sorting: standard'))
|
|
})
|
|
*/
|
|
it('should recognize error: priority indicator alone', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/!
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 15:PriorityNotAllowedOnOutsidersGroup Priority is not allowed for sorting group with empty match-pattern ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/!'))
|
|
})
|
|
it('should recognize error: multiple priority indicators alone', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/! /!! /!!!
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 16:TooManyPriorityPrefixes Only one priority prefix allowed on sorting group ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/! /!! /!!!'))
|
|
})
|
|
it('should recognize error: multiple priority indicators', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/!!! /!!! Abc\.d+ ...
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 16:TooManyPriorityPrefixes Only one priority prefix allowed on sorting group ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/!!! /!!! Abc\.d+ ...'))
|
|
})
|
|
it('should recognize error: priority indicator with empty file pattern', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorPriorityEmptyFilePattern.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 15:PriorityNotAllowedOnOutsidersGroup Priority is not allowed for sorting group with empty match-pattern ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/!! /:'))
|
|
})
|
|
it('should recognize error: priority indicator with empty folder pattern', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorPriorityEmptyFolderPattern.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 15:PriorityNotAllowedOnOutsidersGroup Priority is not allowed for sorting group with empty match-pattern ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/!!! /'))
|
|
})
|
|
it('should recognize error: priority indicator with empty pattern', () => {
|
|
const inputTxtArr: Array<string> = txtInputErrorPriorityEmptyPattern.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 15:PriorityNotAllowedOnOutsidersGroup Priority is not allowed for sorting group with empty match-pattern ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/! %'))
|
|
})
|
|
it('should recognize error of combining: sorting order on first group', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/+ Abc
|
|
> modified
|
|
/+ /:files def
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 20:OnlyLastCombinedGroupCanSpecifyOrder Predecessor group of combined group cannot contain order specification. Put it at the last of group in combined groups ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize error of combining: sorting order not on last group', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/+ Abc
|
|
/+ ...Def
|
|
/+ Ghi...
|
|
> modified
|
|
/+ /:files def
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 20:OnlyLastCombinedGroupCanSpecifyOrder Predecessor group of combined group cannot contain order specification. Put it at the last of group in combined groups ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize error of combining: combining not allowed for outsiders group', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/+ %
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 17:CombiningNotAllowedOnOutsidersGroup Combining is not allowed for sorting group with empty match-pattern ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/+ %'))
|
|
})
|
|
it('should recognize error of combining: combining not allowed for outsiders priority group', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/+ /! /
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 15:PriorityNotAllowedOnOutsidersGroup Priority is not allowed for sorting group with empty match-pattern ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/+ /! /'))
|
|
})
|
|
it('should recognize error of combining: multiple combine operators', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/+ /! /+ /: Something
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 18:TooManyCombinePrefixes Only one combining prefix allowed on sorting group ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/+ /! /+ /: Something'))
|
|
})
|
|
it('should recognize error: too many sorting group type prefixes', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/folders /:files Hello
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 21:TooManyGroupTypePrefixes Only one sorting group type prefix allowed on sorting group ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/folders /:files Hello'))
|
|
})
|
|
it('should recognize error: priority prefix after sorting group type prefixe', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/folders /+ /! Hello
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 22:PriorityPrefixAfterGroupTypePrefix Priority prefix must be used before sorting group type indicator ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/folders /+ /! Hello'))
|
|
})
|
|
it('should recognize error: combine prefix after sorting group type prefix', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
/folders /+ Hello
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 23:CombinePrefixAfterGroupTypePrefix Combining prefix must be used before sorting group type indicator ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('/folders /+ Hello'))
|
|
})
|
|
it('should recognize empty spec', () => {
|
|
const inputTxtArr: Array<string> = txtInputEmptySpec.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(0)
|
|
})
|
|
it.each([
|
|
'% \\.d+...',
|
|
'% ...\\d+',
|
|
'% Chapter\\R+... page',
|
|
'% Section ...\\-r+page'
|
|
])('should recognize error: numeric sorting symbol adjacent to wildcard in >%s<', (s: string) => {
|
|
const inputTxtArr: Array<string> = s.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 10:SortingSymbolAdjacentToWildcard Sorting symbol must not be directly adjacent to a wildcard because of potential performance problem. An additional explicit separator helps in such case. ${ERR_SUFFIX_IN_LINE(1)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT(s))
|
|
})
|
|
it.each([
|
|
'% \\.d+\\d...',
|
|
'% ...[0-9]\\d+',
|
|
'% Chapter\\R+\\d... page',
|
|
'% Section ...[0-9]\\-r+page'
|
|
])('should not recognize adjacency error in >%s<', (s: string) => {
|
|
const inputTxtArr: Array<string> = s.split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).not.toBeNull()
|
|
expect(errorsLogger).not.toHaveBeenCalled()
|
|
})
|
|
it('should recognize empty regexp of target-folder:', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: regexp:
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 27:InvalidOrEmptyFolderMatchingRegexp Invalid or empty folder regexp expression <> ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize error in regexp of target-folder:', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: regexp: bla (
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 27:InvalidOrEmptyFolderMatchingRegexp Invalid or empty folder regexp expression <bla (> ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize empty name in target-folder: name:', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: name:
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 26:EmptyFolderNameToMatch Empty 'target-folder: name:' value ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize duplicate name in target-folder: name:', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
target-folder: name: 123
|
|
target-folder: name: xyz
|
|
target-folder: name: 123
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 25:DuplicateByNameSortSpecForFolder Duplicate 'target-folder: name:' definition for the same name <123> ${ERR_SUFFIX}`)
|
|
})
|
|
it('should recognize unsupported order for by-metadata: (regular orders)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
< modified by-metadata:
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Sorting by metadata requires one of alphabetical orders ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('< modified by-metadata:'))
|
|
})
|
|
it('should recognize unsupported order for by-metadata: (ui selected order)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
< ui selected by-metadata:
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Sorting by metadata requires one of alphabetical orders ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('< ui selected by-metadata:'))
|
|
})
|
|
it('should reject superfluous unrecognized text case A', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: standard, sorting: ui-selected
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Secondary sorting order contains unrecognized text: >>> ui-selected <<< ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('sorting: standard, sorting: ui-selected'))
|
|
})
|
|
it('should reject "sorting" as postfix (comment ignored)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: a-z, a-z sorting // <- reject postfix notation
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Secondary sorting order contains unrecognized text: >>> sorting <<< ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('sorting: a-z, a-z sorting // <- reject postfix notation'))
|
|
})
|
|
it('should reject "order-desc:" as postfix (colon is not needed)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
order-desc: true a-z order-desc: by-metadata:
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Primary sorting order contains unrecognized text: >>> : by-metadata: <<< ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('order-desc: true a-z order-desc: by-metadata:'))
|
|
})
|
|
it('should reject "order-asc:" as postfix (colon is not needed)', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
order-desc: modified, a-z order-asc:
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Secondary sorting order contains unrecognized text: >>> : <<< ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('order-desc: modified, a-z order-asc:'))
|
|
})
|
|
it('should reject "order-asc:" as postfix (colon is not needed) - comment is involved', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
order-desc: modified, a-z order-asc: // Comment intentionally here, some spaces, some comma
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Secondary sorting order contains unrecognized text: >>> : <<< ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('order-desc: modified, a-z order-asc: // Comment intentionally here, some spaces, some comma'))
|
|
})
|
|
it('should reject inconsistent prefix and postfix orders', () => {
|
|
const inputTxtArr: Array<string> = `
|
|
sorting: standard, order-asc: modified desc by-metadata: xyz // <-- and it is checked earlier than the by-metadata incompatible order
|
|
`.replace(/\t/gi, '').split('\n')
|
|
const result = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(2)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(1,
|
|
`${ERR_PREFIX} 7:InvalidAttributeValue Secondary sorting direction order-asc: and desc are contradicting ${ERR_SUFFIX_IN_LINE(2)}`)
|
|
expect(errorsLogger).toHaveBeenNthCalledWith(2, ERR_LINE_TXT('sorting: standard, order-asc: modified desc by-metadata: xyz // <-- and it is checked earlier than the by-metadata incompatible order'))
|
|
})
|
|
})
|
|
|
|
const txtInputTargetFolderCCC: string = `
|
|
target-folder: CCC
|
|
`
|
|
|
|
describe('SortingSpecProcessor advanced error detection', () => {
|
|
it('should retain state of duplicates detection in the instance', () => {
|
|
let processor: SortingSpecProcessor = new SortingSpecProcessor(errorsLogger);
|
|
errorsLogger.mockReset()
|
|
const inputTxtArr: Array<string> = txtInputTargetFolderCCC.split('\n')
|
|
const result1 = processor.parseSortSpecFromText(inputTxtArr, 'another-mock-folder', 'sortspec.md')
|
|
const result2 = processor.parseSortSpecFromText(inputTxtArr, 'mock-folder', 'custom-name-note.md')
|
|
expect(result1).not.toBeNull()
|
|
expect(result2).toBeNull()
|
|
expect(errorsLogger).toHaveBeenCalledTimes(1)
|
|
expect(errorsLogger).toHaveBeenCalledWith(`${ERR_PREFIX} 2:DuplicateSortSpecForSameFolder Duplicate sorting spec for folder CCC ${ERR_SUFFIX}`)
|
|
})
|
|
})
|
|
|
|
describe('convertPlainStringSortingGroupSpecToArraySpec', () => {
|
|
let processor: SortingSpecProcessor;
|
|
beforeEach(() => {
|
|
processor = new SortingSpecProcessor();
|
|
});
|
|
it('should recognize infix', () => {
|
|
const s = 'Advanced adv...ed, etc. and so on'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Advanced adv', '...', 'ed, etc. and so on'
|
|
])
|
|
})
|
|
it('should recognize suffix', () => {
|
|
const s = 'Advanced... '
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Advanced', '...'
|
|
])
|
|
})
|
|
it('should recognize prefix', () => {
|
|
const s = ' ...tion. !!!'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'...', 'tion. !!!'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 0', () => {
|
|
const s = './...'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'.', '...'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 1', () => {
|
|
const s = '../...'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'..', '...'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 2', () => {
|
|
const s = './...Some'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'.', '...', 'Some'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 3', () => {
|
|
const s = 'Some./...'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some.','...'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 3a', () => {
|
|
const s = 'Some./.....'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some./..','...'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 3b', () => {
|
|
const s = 'Some./.....X'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some.','...', '..X'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - variant 4', () => {
|
|
const s = 'Some./...Some'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some.','...', 'Some'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - tricky variant 4', () => {
|
|
const s = 'Some./... haha ...Some'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some.','...', ' haha ...Some'
|
|
])
|
|
})
|
|
it('should recognize four dots escaper - tricky variant 5', () => {
|
|
const s = 'S.../..'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'S','...', '/..'
|
|
])
|
|
})
|
|
it('should NOT recognize four dots escaper - tricky variant 1', () => {
|
|
const s = 'Some... haha ./...Some'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some','...', ' haha ./...Some'
|
|
])
|
|
})
|
|
it('should NOT recognize four dots escaper - tricky variant 2', () => {
|
|
const s = 'Some... haha .../...Some'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Some', '...', ' haha .../...Some'
|
|
])
|
|
})
|
|
it('should NOT recognize four dots escaper - tricky variant 3', () => {
|
|
const s = '.../...'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'...', '/...'
|
|
])
|
|
})
|
|
it('should recognize some edge case', () => {
|
|
const s = 'Edge...... ... ..... ... eee?'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Edge', '...', '... ... ..... ... eee?'
|
|
])
|
|
})
|
|
it('should recognize some other edge case', () => {
|
|
const s = 'Edge... ... ... ..... ... eee?'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'Edge', '...', ' ... ... ..... ... eee?'
|
|
])
|
|
})
|
|
it('should recognize another edge case', () => {
|
|
const s = '...Edge ... ... ... ..... ... eee? ...'
|
|
expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
|
|
'...', 'Edge ... ... ... ..... ... eee? ...'
|
|
])
|
|
})
|
|
it('should recognize yet another edge case', () => {
|
|
const s = '. .. ... ...'
|
|
const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
|
|
expect(result).toEqual([
|
|
'. .. ... ', '...' // Edge case -> splitting here is neutral, syntax error should be raised later on
|
|
])
|
|
})
|
|
it('should recognize tricky edge case', () => {
|
|
const s = '... ...'
|
|
const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
|
|
expect(result).toEqual([
|
|
'...', ' ...' // Edge case -> splitting here is neutral, syntax error should be raised later on
|
|
])
|
|
})
|
|
it('should recognize a variant of tricky edge case', () => {
|
|
const s = '......'
|
|
const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
|
|
expect(result).toEqual([
|
|
'...', '...' // Edge case -> splitting here is neutral, syntax error should be raised later on
|
|
])
|
|
})
|
|
it('edge case behavior', () => {
|
|
const s = ' ...... .......... '
|
|
const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
|
|
expect(result).toEqual([
|
|
'...', '... ..........' // Edge case -> splitting here is neutral, syntax error should be raised later on
|
|
])
|
|
})
|
|
it('intentional edge case parsing', () => {
|
|
const s = ' Abc......def..........ghi '
|
|
const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
|
|
expect(result).toEqual([
|
|
'Abc', '...', '...def..........ghi' // Edge case -> splitting here is neutral, syntax error should be raised later on
|
|
])
|
|
})
|
|
it.each([
|
|
' ... ',
|
|
'... ',
|
|
' ...'
|
|
])('should not split >%s< and only trim', (s: string) => {
|
|
const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
|
|
expect(result).toEqual([s.trim()])
|
|
})
|
|
})
|
|
|
|
describe('escapeRegexUnsafeCharacters', () => {
|
|
it.each([
|
|
['^', '\\^'],
|
|
['...', '\\.\\.\\.'],
|
|
[' \\ ', ' \\\\ '],
|
|
['^$.-+[]{}()|\\*?=!', '\\^\\$\\.\\-\\+\\[\\]\\{\\}\\(\\)\\|\\\\\\*\\?\\=\\!'],
|
|
['^Chapter \\.d+ -', '\\^Chapter \\\\\\.d\\+ \\-']
|
|
])('should correctly escape >%s< to >%s<', (s: string, ss: string) => {
|
|
// const UnsafeRegexChars: string = '^$.-+[]{}()|\\*?=!';
|
|
const result = escapeRegexUnsafeCharacters(s)
|
|
expect(result).toBe(ss);
|
|
})
|
|
})
|
|
|
|
describe('detectSortingSymbols', () => {
|
|
it.each([
|
|
['', false],
|
|
['d+', false],
|
|
['\\d +', false],
|
|
['\\ d +', false],
|
|
['\\D+', true], [' \\D+ ', true],
|
|
['\\.D+', true], [' \\.D+ ', true],
|
|
['\\-D+', true], [' \\-D+ ', true],
|
|
['\\r+', true], [' \\r+ ', true],
|
|
['\\.r+', true], [' \\.r+ ', true],
|
|
['\\-r+', true], [' \\-r+ ', true],
|
|
['\\d+abcd\\d+efgh', true],
|
|
['\\d+\\.D+\\-d+\\R+\\.r+\\-R+ \\d+', true]
|
|
])('should correctly detect in >%s< (%s) sorting regex symbols', (s: string, b: boolean) => {
|
|
const result = detectSortingSymbols(s)
|
|
expect(result).toBe(b)
|
|
})
|
|
})
|
|
|
|
describe('hasMoreThanOneSortingSymbol', () => {
|
|
it.each([
|
|
['', false],
|
|
[' d+', false],
|
|
['\\d +', false],
|
|
['\\ d +', false],
|
|
[' \\D+', false], [' \\D+ \\R+ ', true],
|
|
[' \\.D+', false], ['\\.D+ \\.R+', true],
|
|
[' \\-D+ ', false], [' \\-D+\\-R+', true],
|
|
['\\r+', false], [' \\r+ \\D+ ', true],
|
|
['\\.r+', false], ['ab\\.r+de\\.D+fg', true],
|
|
['\\-r+', false], ['--\\-r+--\\-D+++', true],
|
|
['\\d+abcd\\d+efgh', true],
|
|
['\\R+abcd\\.R+efgh', true],
|
|
['\\d+\\.D+\\-d+\\R+\\.r+\\-R+ \\d+', true]
|
|
])('should correctly detect in >%s< (%s) sorting regex symbols', (s: string, b: boolean) => {
|
|
const result = hasMoreThanOneSortingSymbol(s)
|
|
expect(result).toBe(b)
|
|
})
|
|
})
|
|
|
|
describe('extractSortingSymbol', () => {
|
|
it.each([
|
|
['', null],
|
|
['d+', null],
|
|
[' \\d +', null],
|
|
[' [0-9]', null],
|
|
['\\ d +', null],
|
|
[' \\d+', '\\d+'],
|
|
['--\\.D+\\d+', '\\.D+'],
|
|
['wdwqwqe\\d+\\.D+\\-d+\\R+\\.r+\\-R+ \\d+', '\\d+']
|
|
])('should correctly extract from >%s< the numeric sorting symbol (%s)', (s: string, ss: string) => {
|
|
const result = extractSortingSymbol(s)
|
|
expect(result).toBe(ss)
|
|
})
|
|
})
|
|
|
|
describe('convertPlainStringWithNumericSortingSymbolToRegex', () => {
|
|
it.each([
|
|
// Advanced numeric symbols
|
|
[' \\d+ ', / *(\d+) /i],
|
|
['Chapter \\D+:', /Chapter *(\d+):/i],
|
|
['Section \\.D+ of', /Section *(\d+(?:\.\d+)*) of/i],
|
|
['Part\\-D+:', /Part *(\d+(?:-\d+)*):/i],
|
|
['Lorem ipsum\\r+:', /Lorem ipsum *([MDCLXVI]+):/i],
|
|
['\\.r+', / *([MDCLXVI]+(?:\.[MDCLXVI]+)*)/i],
|
|
['\\-r+:Lorem', / *([MDCLXVI]+(?:-[MDCLXVI]+)*):Lorem/i],
|
|
// Simple regex
|
|
['\\d-\\[0-9];-)', /\d\-[0-9];\-\)/i],
|
|
['[0-9]\\d[0-9]', /\[0\-9\]\d\[0\-9\]/i],
|
|
['\\[0-9]', /[0-9]/i],
|
|
['[0-9] \\d', /\[0\-9\] \d/i],
|
|
[' \\dd ', / \dd /i],
|
|
[' \\d\\d \\[0-9] ', / \d\d [0-9] /i],
|
|
[' \\d 123 \\[0-9] ', / \d 123 [0-9] /i],
|
|
// Advanced numeric symbols in connection with simple regex
|
|
['\\dLorem ipsum\\r+:', /\dLorem ipsum *([MDCLXVI]+):/i],
|
|
['W\\dLorem ipsum\\r+:', /W\dLorem ipsum *([MDCLXVI]+):/i],
|
|
['Lorem \\d\\r+\\dipsum:', /Lorem \d *([MDCLXVI]+)\dipsum:/i],
|
|
['Lorem \\d\\D+\\dipsum:', /Lorem \d *(\d+)\dipsum:/i],
|
|
// Edge case to act as spec - actually the three dots ... should never reach conversion to regex
|
|
['% \\.d+\\d...', /% *(\d+(?:\.\d+)*)\d\.\.\./i],
|
|
['% ...[0-9]\\d+', /% \.\.\.\[0\-9\] *(\d+)/i],
|
|
['% Chapter\\R+\\d... page', /% Chapter *([MDCLXVI]+)\d\.\.\. page/i],
|
|
['% Section ...[0-9]\\-r+page', /% Section \.\.\.\[0\-9\] *([MDCLXVI]+(?:-[MDCLXVI]+)*)page/i],
|
|
// Edge and error cases, behavior covered by tests to act as specification of the engine here
|
|
// even if at run-time the error checking prevents some such expressions
|
|
['abc\\d+efg\\d+hij', /abc *(\d+)efg/i], // Double advanced numerical sorting symbol, error case
|
|
['--\\.D+\\d+', /\-\- *(\d+(?:\.\d+)*)\d\+/i], // Two advanced numerical symbols
|
|
])('should correctly extract from >%s< the numeric sorting symbol (%s)', (s: string, regex: RegExp) => {
|
|
const result = convertPlainStringToRegex(s, RegexpUsedAs.InUnitTest)
|
|
expect(result?.regexpSpec.regex).toEqual(regex)
|
|
// No need to examine prefix and suffix fields of result, they are secondary and derived from the returned regexp
|
|
})
|
|
it('should not process string not containing numeric sorting symbol nor regex', () => {
|
|
const input1 = 'abc'
|
|
const input2 = '[0-9]'
|
|
const result1 = convertPlainStringToRegex(input1, RegexpUsedAs.InUnitTest)
|
|
const result2 = convertPlainStringToRegex(input2, RegexpUsedAs.InUnitTest)
|
|
expect(result1).toBeNull()
|
|
expect(result2).toBeNull()
|
|
})
|
|
it('should correctly include regex token for string begin', () => {
|
|
const input1 = 'Part\\-D+:'
|
|
const input2 = '\\dPart'
|
|
const result1 = convertPlainStringToRegex(input1, RegexpUsedAs.Prefix)
|
|
const result2 = convertPlainStringToRegex(input2, RegexpUsedAs.Prefix)
|
|
expect(result1?.regexpSpec.regex).toEqual(/^Part *(\d+(?:-\d+)*):/i)
|
|
expect(result2?.regexpSpec.regex).toEqual(/^\dPart/i)
|
|
})
|
|
it('should correctly include regex token for string end', () => {
|
|
const input1 = 'Part\\-D+:'
|
|
const input2 = ' \\[0-9]\\-D+'
|
|
const input3 = ' \\l\\[0-9]\\-D+'
|
|
const result1 = convertPlainStringToRegex(input1, RegexpUsedAs.Suffix)
|
|
const result2 = convertPlainStringToRegex(input2, RegexpUsedAs.Suffix)
|
|
const result3 = convertPlainStringToRegex(input3, RegexpUsedAs.Suffix)
|
|
expect(result1?.regexpSpec.regex).toEqual(/Part *(\d+(?:-\d+)*):$/i)
|
|
expect(result2?.regexpSpec.regex).toEqual(/ [0-9] *(\d+(?:-\d+)*)$/i)
|
|
expect(result3?.regexpSpec.regex).toEqual(/ \p{Ll}[0-9] *(\d+(?:-\d+)*)$/u)
|
|
})
|
|
it('should correctly include regex token for string begin and end', () => {
|
|
const input1 = 'Part\\.D+:'
|
|
const input2 = ' \\d \\[0-9] '
|
|
const input3 = ' \\d \\[0-9] \\C'
|
|
const result1 = convertPlainStringToRegex(input1, RegexpUsedAs.FullMatch)
|
|
const result2 = convertPlainStringToRegex(input2, RegexpUsedAs.FullMatch)
|
|
const result3 = convertPlainStringToRegex(input3, RegexpUsedAs.FullMatch)
|
|
expect(result1?.regexpSpec.regex).toEqual(/^Part *(\d+(?:\.\d+)*):$/i)
|
|
expect(result2?.regexpSpec.regex).toEqual(/^ \d [0-9] $/i)
|
|
expect(result3?.regexpSpec.regex).toEqual(/^ \d [0-9] [\p{Lu}\p{Lt}]$/u)
|
|
})
|
|
})
|