Don't normalize file patterns

README.md

@@ -256,8 +256,7 @@ The object structure is as follows:
 }
 ```
 #### { src; dest } Object Rules
- - if `src` is a non-glob path to a single file, then `dest` should include the filename and extension. For example:
- `{ src: "lib/Promise/promise.brs", dest: "source/promise.brs"}`
+- if `src` is a non-glob path to a single file, then `dest` should include the filename and extension. For example:
 
  - if `src` is a glob pattern, then `dest` should be a path to the folder in the output directory. For example:
  `{ src: "lib/*.brs", dest: "source/lib"}`
@@ -326,7 +325,7 @@ Here are the available options. The defaults are shown to the right of the optio
         "manifest"
     ]
     ```
-    An array of file paths, globs, or {src:string;dest:string} objects that will be copied into the deployment package.
+    An array of file paths, globs, or `{ src: string; dest: string }` objects that will be copied into the deployment package. Make sure to _exclusively_ use forward slashes ( `/` ) for path separators (even on Windows), as backslashes are reserved for character escaping. You can learn more about this requirement [here](https://www.npmjs.com/package/fast-glob?activeTab=readme#how-to-write-patterns-on-windows).
 
     Using the {src;dest} objects will allow you to move files into different destination paths in the
     deployment package. This would be useful for copying environment-specific configs into a common config location

src/RokuDeploy.spec.ts

@@ -11,7 +11,7 @@ import * as glob from 'glob';
 import type { BeforeZipCallbackInfo } from './RokuDeploy';
 import { RokuDeploy } from './RokuDeploy';
 import * as errors from './Errors';
-import { util, standardizePath as s } from './util';
+import { util, standardizePath as s, standardizePathPosix as sp } from './util';
 import type { FileEntry, RokuDeployOptions } from './RokuDeployOptions';
 import { cwd, expectPathExists, expectPathNotExists, expectThrowsAsync, outDir, rootDir, stagingDir, tempDir, writeFiles } from './testUtils.spec';
 import { createSandbox } from 'sinon';
@@ -1722,7 +1722,7 @@ describe('index', () => {
             await rokuDeploy.prepublishToStaging({
                 files: [
                     {
-                        src: `${rootDir}/manifest`,
+                        src: sp`${rootDir}/manifest`,
                         dest: ''
                     },
                     {
@@ -2093,7 +2093,7 @@ describe('index', () => {
                 src: `long/source/path`,
                 dest: `long/dest/path`
             }])).to.eql([{
-                src: s`long/source/path`,
+                src: sp`long/source/path`,
                 dest: s`long/dest/path`
             }]);
         });
@@ -2151,7 +2151,7 @@ describe('index', () => {
                 src: 'manifest',
                 dest: undefined
             }, {
-                src: s`source/main.brs`,
+                src: sp`source/main.brs`,
                 dest: undefined
             }]);
         });
@@ -2163,7 +2163,7 @@ describe('index', () => {
                     dest: 'source/config.brs'
                 }
             ])).to.eql([{
-                src: s`source/config.dev.brs`,
+                src: sp`source/config.dev.brs`,
                 dest: s`source/config.brs`
             }]);
         });
@@ -2651,7 +2651,7 @@ describe('index', () => {
 
     describe('getFilePaths', () => {
         const otherProjectName = 'otherProject';
-        const otherProjectDir = s`${rootDir}/../${otherProjectName}`;
+        const otherProjectDir = sp`${rootDir}/../${otherProjectName}`;
         //create baseline project structure
         beforeEach(() => {
             fsExtra.ensureDirSync(`${rootDir}/components/emptyFolder`);
@@ -2817,6 +2817,31 @@ describe('index', () => {
                 }]);
             });
 
+            it('Finds folder using square brackets glob pattern', async () => {
+                fsExtra.outputFileSync(`${rootDir}/e/file.brs`, '');
+                expect(await getFilePaths([
+                    '[test]/*'
+                ],
+                rootDir
+                )).to.eql([{
+                    src: s`${rootDir}/e/file.brs`,
+                    dest: s`e/file.brs`
+                }]);
+            });
+
+            it('Finds folder with escaped square brackets glob pattern as name', async () => {
+                fsExtra.outputFileSync(`${rootDir}/[test]/file.brs`, '');
+                fsExtra.outputFileSync(`${rootDir}/e/file.brs`, '');
+                expect(await getFilePaths([
+                    '\\[test\\]/*'
+                ],
+                rootDir
+                )).to.eql([{
+                    src: s`${rootDir}/[test]/file.brs`,
+                    dest: s`[test]/file.brs`
+                }]);
+            });
+
             it('throws exception when top-level strings reference files not under rootDir', async () => {
                 writeFiles(otherProjectDir, [
                     'manifest'
@@ -3139,15 +3164,15 @@ describe('index', () => {
 
             //dest not specified
             expect(await rokuDeploy.getFilePaths([{
-                src: s`${cwd}/README.md`
+                src: sp`${cwd}/README.md`
             }], options.rootDir)).to.eql([{
                 src: s`${cwd}/README.md`,
                 dest: s`README.md`
             }]);
 
             //dest specified
             expect(await rokuDeploy.getFilePaths([{
-                src: path.join(cwd, 'README.md'),
+                src: sp`${cwd}/README.md`,
                 dest: 'docs/README.md'
             }], options.rootDir)).to.eql([{
                 src: s`${cwd}/README.md`,
@@ -3157,7 +3182,7 @@ describe('index', () => {
             let paths: any[];
 
             paths = await rokuDeploy.getFilePaths([{
-                src: s`${cwd}/README.md`,
+                src: sp`${cwd}/README.md`,
                 dest: s`docs/README.md`
             }], outDir);
 
@@ -3169,7 +3194,7 @@ describe('index', () => {
             //top-level string paths pointing to files outside the root should thrown an exception
             await expectThrowsAsync(async () => {
                 paths = await rokuDeploy.getFilePaths([
-                    s`${cwd}/README.md`
+                    sp`${cwd}/README.md`
                 ], outDir);
             });
         });
@@ -3180,7 +3205,7 @@ describe('index', () => {
             ]);
             expect(
                 await rokuDeploy.getFilePaths([{
-                    src: path.join('..', 'README.md')
+                    src: sp`../README.md`
                 }], rootDir)
             ).to.eql([{
                 src: s`${rootDir}/../README.md`,
@@ -3189,7 +3214,7 @@ describe('index', () => {
 
             expect(
                 await rokuDeploy.getFilePaths([{
-                    src: path.join('..', 'README.md'),
+                    src: sp`../README.md`,
                     dest: 'docs/README.md'
                 }], rootDir)
             ).to.eql([{
@@ -3204,17 +3229,17 @@ describe('index', () => {
             ]);
             await expectThrowsAsync(
                 rokuDeploy.getFilePaths([
-                    path.join('..', 'README.md')
+                    path.posix.join('..', 'README.md')
                 ], outDir)
             );
         });
 
         it('supports overriding paths', async () => {
             let paths = await rokuDeploy.getFilePaths([{
-                src: s`${rootDir}/components/component1.brs`,
+                src: sp`${rootDir}/components/component1.brs`,
                 dest: 'comp1.brs'
             }, {
-                src: s`${rootDir}/components/screen1/screen1.brs`,
+                src: sp`${rootDir}/components/screen1/screen1.brs`,
                 dest: 'comp1.brs'
             }], rootDir);
             expect(paths).to.be.lengthOf(1);

src/RokuDeploy.ts

@@ -77,7 +77,7 @@ export class RokuDeploy {
                 //objects with src: string
                 if (typeof entry.src === 'string') {
                     result.push({
-                        src: util.standardizePath(entry.src),
+                        src: entry.src,
                         dest: util.standardizePath(entry.dest)
                     });
 
@@ -86,7 +86,7 @@ export class RokuDeploy {
                     //create a distinct entry for each item in the src array
                     for (let srcEntry of entry.src) {
                         result.push({
-                            src: util.standardizePath(srcEntry),
+                            src: srcEntry,
                             dest: util.standardizePath(entry.dest)
                         });
                     }

src/util.spec.ts

@@ -26,14 +26,16 @@ describe('util', () => {
         });
     });
 
-    describe('toForwardSlashes', () => {
-        it('returns original value for non-strings', () => {
-            expect(util.toForwardSlashes(undefined)).to.be.undefined;
-            expect(util.toForwardSlashes(<any>false)).to.be.false;
+    describe('standardizePathPosix', () => {
+        it('returns falsey value back unchanged', () => {
+            expect(util.standardizePathPosix(null)).to.eql(null);
+            expect(util.standardizePathPosix(undefined)).to.eql(undefined);
+            expect(util.standardizePathPosix(false as any)).to.eql(false);
+            expect(util.standardizePathPosix(0 as any)).to.eql(0);
         });
 
-        it('converts mixed slashes to forward', () => {
-            expect(util.toForwardSlashes('a\\b/c\\d/e')).to.eql('a/b/c/d/e');
+        it('always returns forward slashes', () => {
+            expect(util.standardizePathPosix('C:\\projects/some\\folder')).to.eql('C:/projects/some/folder');
         });
     });
 

src/util.ts

@@ -46,22 +46,21 @@ export class Util {
         if (!thePath) {
             return thePath;
         }
-        return path.normalize(
-            thePath.replace(/[\/\\]+/g, path.sep)
-        );
+        return path.normalize(thePath).replace(/[\/\\]+/g, path.sep);
     }
 
     /**
-     * Convert all slashes to forward slashes
+     * Normalize path and replace all directory separators with current OS separators
+     * @param thePath
      */
-    public toForwardSlashes(thePath: string) {
-        if (typeof thePath === 'string') {
-            return thePath.replace(/[\/\\]+/g, '/');
-        } else {
+    public standardizePathPosix(thePath: string) {
+        if (!thePath) {
             return thePath;
         }
+        return path.normalize(thePath).replace(/[\/\\]+/g, '/');
     }
 
+
     /**
      * Do a case-insensitive string replacement
      * @param subject the string that will have its contents replaced
@@ -140,8 +139,6 @@ export class Util {
         cwd = cwd.replace(/\\/g, '/');
 
         const globResults = patterns.map(async (pattern) => {
-            //force all windows-style slashes to unix style
-            pattern = pattern.replace(/\\/g, '/');
             //skip negated patterns (we will use them to filter later on)
             if (pattern.startsWith('!')) {
                 return pattern;
@@ -245,3 +242,16 @@ export function standardizePath(stringParts, ...expressions: any[]) {
         result.join('')
     );
 }
+
+/**
+ * A tagged template literal function for standardizing the path and making all path separators forward slashes
+ */
+export function standardizePathPosix(stringParts, ...expressions: any[]) {
+    let result = [];
+    for (let i = 0; i < stringParts.length; i++) {
+        result.push(stringParts[i], expressions[i]);
+    }
+    return util.standardizePathPosix(
+        result.join('')
+    );
+}