mirror of
https://github.com/pulsar-edit/pulsar.git
synced 2024-09-11 11:15:24 +03:00
238 lines
7.5 KiB
JavaScript
238 lines
7.5 KiB
JavaScript
/** @babel */
|
|
import path from 'path';
|
|
|
|
import PackageTranspilationRegistry from '../src/package-transpilation-registry';
|
|
|
|
const originalCompiler = {
|
|
getCachePath: (sourceCode, filePath) => {
|
|
return 'orig-cache-path';
|
|
},
|
|
|
|
compile: (sourceCode, filePath) => {
|
|
return sourceCode + '-original-compiler';
|
|
},
|
|
|
|
shouldCompile: (sourceCode, filePath) => {
|
|
return path.extname(filePath) === '.js';
|
|
}
|
|
};
|
|
|
|
describe('PackageTranspilationRegistry', () => {
|
|
let registry;
|
|
let wrappedCompiler;
|
|
|
|
beforeEach(() => {
|
|
registry = new PackageTranspilationRegistry();
|
|
wrappedCompiler = registry.wrapTranspiler(originalCompiler);
|
|
});
|
|
|
|
it('falls through to the original compiler by default', () => {
|
|
spyOn(originalCompiler, 'getCachePath');
|
|
spyOn(originalCompiler, 'compile');
|
|
spyOn(originalCompiler, 'shouldCompile');
|
|
|
|
wrappedCompiler.getCachePath('source', '/path/to/file.js');
|
|
wrappedCompiler.compile('source', '/path/to/filejs');
|
|
wrappedCompiler.shouldCompile('source', '/path/to/file.js');
|
|
|
|
expect(originalCompiler.getCachePath).toHaveBeenCalled();
|
|
expect(originalCompiler.compile).toHaveBeenCalled();
|
|
expect(originalCompiler.shouldCompile).toHaveBeenCalled();
|
|
});
|
|
|
|
describe('when a file is contained in a path that has custom transpilation', () => {
|
|
const hitPath = path.join('/path/to/lib/file.js');
|
|
const hitPathCoffee = path.join('/path/to/file2.coffee');
|
|
const missPath = path.join('/path/other/file3.js');
|
|
const hitPathMissSubdir = path.join('/path/to/file4.js');
|
|
const hitPathMissExt = path.join('/path/to/file5.ts');
|
|
const nodeModulesFolder = path.join('/path/to/lib/node_modules/file6.js');
|
|
const hitNonStandardExt = path.join('/path/to/file7.omgwhatisthis');
|
|
|
|
const jsSpec = {
|
|
glob: 'lib/**/*.js',
|
|
transpiler: './transpiler-js',
|
|
options: { type: 'js' }
|
|
};
|
|
const coffeeSpec = {
|
|
glob: '*.coffee',
|
|
transpiler: './transpiler-coffee',
|
|
options: { type: 'coffee' }
|
|
};
|
|
const omgSpec = {
|
|
glob: '*.omgwhatisthis',
|
|
transpiler: './transpiler-omg',
|
|
options: { type: 'omg' }
|
|
};
|
|
|
|
const expectedMeta = {
|
|
name: 'my-package',
|
|
path: path.join('/path/to'),
|
|
meta: { some: 'metadata' }
|
|
};
|
|
|
|
const jsTranspiler = {
|
|
transpile: (sourceCode, filePath, options) => {
|
|
return { code: sourceCode + '-transpiler-js' };
|
|
},
|
|
|
|
getCacheKeyData: (sourceCode, filePath, options) => {
|
|
return 'js-transpiler-cache-data';
|
|
}
|
|
};
|
|
|
|
const coffeeTranspiler = {
|
|
transpile: (sourceCode, filePath, options) => {
|
|
return { code: sourceCode + '-transpiler-coffee' };
|
|
},
|
|
|
|
getCacheKeyData: (sourceCode, filePath, options) => {
|
|
return 'coffee-transpiler-cache-data';
|
|
}
|
|
};
|
|
|
|
const omgTranspiler = {
|
|
transpile: (sourceCode, filePath, options) => {
|
|
return { code: sourceCode + '-transpiler-omg' };
|
|
},
|
|
|
|
getCacheKeyData: (sourceCode, filePath, options) => {
|
|
return 'omg-transpiler-cache-data';
|
|
}
|
|
};
|
|
|
|
beforeEach(() => {
|
|
jsSpec._transpilerSource = 'js-transpiler-source';
|
|
coffeeSpec._transpilerSource = 'coffee-transpiler-source';
|
|
omgTranspiler._transpilerSource = 'omg-transpiler-source';
|
|
|
|
spyOn(registry, 'getTranspiler').andCallFake(spec => {
|
|
if (spec.transpiler === './transpiler-js') return jsTranspiler;
|
|
if (spec.transpiler === './transpiler-coffee') return coffeeTranspiler;
|
|
if (spec.transpiler === './transpiler-omg') return omgTranspiler;
|
|
throw new Error('bad transpiler path ' + spec.transpiler);
|
|
});
|
|
|
|
registry.addTranspilerConfigForPath(
|
|
path.join('/path/to'),
|
|
'my-package',
|
|
{ some: 'metadata' },
|
|
[jsSpec, coffeeSpec, omgSpec]
|
|
);
|
|
});
|
|
|
|
it('always returns true from shouldCompile for a file in that dir that match a glob', () => {
|
|
spyOn(originalCompiler, 'shouldCompile').andReturn(false);
|
|
expect(wrappedCompiler.shouldCompile('source', hitPath)).toBe(true);
|
|
expect(wrappedCompiler.shouldCompile('source', hitPathCoffee)).toBe(true);
|
|
expect(wrappedCompiler.shouldCompile('source', hitNonStandardExt)).toBe(
|
|
true
|
|
);
|
|
expect(wrappedCompiler.shouldCompile('source', hitPathMissExt)).toBe(
|
|
false
|
|
);
|
|
expect(wrappedCompiler.shouldCompile('source', hitPathMissSubdir)).toBe(
|
|
false
|
|
);
|
|
expect(wrappedCompiler.shouldCompile('source', missPath)).toBe(false);
|
|
expect(wrappedCompiler.shouldCompile('source', nodeModulesFolder)).toBe(
|
|
false
|
|
);
|
|
});
|
|
|
|
it('calls getCacheKeyData on the transpiler to get additional cache key data', () => {
|
|
spyOn(registry, 'getTranspilerPath').andReturn('./transpiler-js');
|
|
spyOn(jsTranspiler, 'getCacheKeyData').andCallThrough();
|
|
|
|
wrappedCompiler.getCachePath('source', missPath, jsSpec);
|
|
expect(jsTranspiler.getCacheKeyData).not.toHaveBeenCalledWith(
|
|
'source',
|
|
missPath,
|
|
jsSpec.options,
|
|
expectedMeta
|
|
);
|
|
wrappedCompiler.getCachePath('source', hitPath, jsSpec);
|
|
expect(jsTranspiler.getCacheKeyData).toHaveBeenCalledWith(
|
|
'source',
|
|
hitPath,
|
|
jsSpec.options,
|
|
expectedMeta
|
|
);
|
|
});
|
|
|
|
it('compiles files matching a glob with the associated transpiler, and the old one otherwise', () => {
|
|
spyOn(jsTranspiler, 'transpile').andCallThrough();
|
|
spyOn(coffeeTranspiler, 'transpile').andCallThrough();
|
|
spyOn(omgTranspiler, 'transpile').andCallThrough();
|
|
|
|
expect(wrappedCompiler.compile('source', hitPath)).toEqual(
|
|
'source-transpiler-js'
|
|
);
|
|
expect(jsTranspiler.transpile).toHaveBeenCalledWith(
|
|
'source',
|
|
hitPath,
|
|
jsSpec.options,
|
|
expectedMeta
|
|
);
|
|
expect(wrappedCompiler.compile('source', hitPathCoffee)).toEqual(
|
|
'source-transpiler-coffee'
|
|
);
|
|
expect(coffeeTranspiler.transpile).toHaveBeenCalledWith(
|
|
'source',
|
|
hitPathCoffee,
|
|
coffeeSpec.options,
|
|
expectedMeta
|
|
);
|
|
expect(wrappedCompiler.compile('source', hitNonStandardExt)).toEqual(
|
|
'source-transpiler-omg'
|
|
);
|
|
expect(omgTranspiler.transpile).toHaveBeenCalledWith(
|
|
'source',
|
|
hitNonStandardExt,
|
|
omgSpec.options,
|
|
expectedMeta
|
|
);
|
|
|
|
expect(wrappedCompiler.compile('source', missPath)).toEqual(
|
|
'source-original-compiler'
|
|
);
|
|
expect(wrappedCompiler.compile('source', hitPathMissExt)).toEqual(
|
|
'source-original-compiler'
|
|
);
|
|
expect(wrappedCompiler.compile('source', hitPathMissSubdir)).toEqual(
|
|
'source-original-compiler'
|
|
);
|
|
expect(wrappedCompiler.compile('source', nodeModulesFolder)).toEqual(
|
|
'source-original-compiler'
|
|
);
|
|
});
|
|
|
|
describe('when the packages root path contains node_modules', () => {
|
|
beforeEach(() => {
|
|
registry.addTranspilerConfigForPath(
|
|
path.join('/path/with/node_modules/in/root'),
|
|
'my-other-package',
|
|
{ some: 'metadata' },
|
|
[jsSpec]
|
|
);
|
|
});
|
|
|
|
it('returns appropriate values from shouldCompile', () => {
|
|
spyOn(originalCompiler, 'shouldCompile').andReturn(false);
|
|
expect(
|
|
wrappedCompiler.shouldCompile(
|
|
'source',
|
|
'/path/with/node_modules/in/root/lib/test.js'
|
|
)
|
|
).toBe(true);
|
|
expect(
|
|
wrappedCompiler.shouldCompile(
|
|
'source',
|
|
'/path/with/node_modules/in/root/lib/node_modules/test.js'
|
|
)
|
|
).toBe(false);
|
|
});
|
|
});
|
|
});
|
|
});
|