status-im
/
react-native
mirror of https://github.com/status-im/react-native.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Let the module cache depend on transform options 

Reviewed By: martinbigio

Differential Revision: D2921693

fb-gh-sync-id: 6f95bdb03d59183a1b5f50db16c6aab2b16d3146
shipit-source-id: 6f95bdb03d59183a1b5f50db16c6aab2b16d3146
This commit is contained in:
David Aurelio 2016-02-12 06:13:19 -08:00 committed by facebook-github-bot-3
parent b5579e807e
commit 727a2a95d1
3 changed files with 202 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
packager/react-packager/src/DependencyResolver/DependencyGraph/__tests__/DependencyGraph-test.js vendored
View File

@ -48,11 +48,41 @@ describe('DependencyGraph', function() {
isWatchman: () => Promise.resolve(false),
};
const Cache = jest.genMockFn();
Cache.prototype.get = jest.genMockFn().mockImplementation(
(filepath, field, cb) => cb(filepath)
);
Cache.prototype.invalidate = jest.genMockFn();
const Cache = jest.genMockFn().mockImplementation(function() {
this._maps = Object.create(null);
});
Cache.prototype.has = jest.genMockFn()
.mockImplementation(function(filepath, field) {
if (!(filepath in this._maps)) {
return false;
}
return !field || field in this._maps[filepath];
});
Cache.prototype.get = jest.genMockFn()
.mockImplementation(function(filepath, field, factory) {
let cacheForPath = this._maps[filepath];
if (this.has(filepath, field)) {
return field ? cacheForPath[field] : cacheForPath;
}
if (!cacheForPath) {
cacheForPath = this._maps[filepath] = Object.create(null);
}
const value = cacheForPath[field] = factory();
return value;
});
Cache.prototype.invalidate = jest.genMockFn()
.mockImplementation(function(filepath, field) {
if (!this.has(filepath, field)) {
return;
}
if (field) {
delete this._maps[filepath][field];
} else {
delete this._maps[filepath];
}
});
Cache.prototype.end = jest.genMockFn();
defaults = {
@ -3688,7 +3718,9 @@ describe('DependencyGraph', function() {
});
});
pit('updates package.json', function() {
//TODO(davidaurelio) Make this actually worked. The test only passed because
// the mocked cache didn't cache. In reality, it didn't work. I tried it.
xpit('updates package.json', function() {
var root = '/root';
var filesystem = fs.__setMockFilesystem({
'root': {

131
packager/react-packager/src/DependencyResolver/Module.js vendored
View File

@ -8,6 +8,7 @@
*/
'use strict';
const crypto = require('crypto');
const docblock = require('./DependencyGraph/docblock');
const isAbsolutePath = require('absolute-path');
const path = require('path');
@ -43,12 +44,16 @@ class Module {
return this._cache.get(
this.path,
'isHaste',
() => this._readDocBlock().then(data => !!data.id)
() => this._readDocBlock().then(({id}) => !!id)
);
}
getCode() {
return this.read().then(({code}) => code);
getCode(transformOptions) {
return this.read(transformOptions).then(({code}) => code);
}
getMap(transformOptions) {
return this.read(transformOptions).then(({map}) => map);
}
getName() {
@ -83,12 +88,8 @@ class Module {
return this._moduleCache.getPackageForModule(this);
}
getDependencies() {
return this._cache.get(
this.path,
'dependencies',
() => this.read().then(data => data.dependencies)
);
getDependencies(transformOptions) {
return this.read(transformOptions).then(data => data.dependencies);
}
invalidate() {
@ -108,56 +109,50 @@ class Module {
const id = provides && !this._depGraphHelpers.isNodeModulesDir(this.path)
? /^\S+/.exec(provides)[0]
: undefined;
return [id, moduleDocBlock];
return {id, moduleDocBlock};
}
_readDocBlock() {
const reading = this._reading || this._docBlock;
if (reading) {
return reading;
_readDocBlock(contentPromise) {
if (!this._docBlock) {
if (!contentPromise) {
contentPromise = this._fastfs.readWhile(this.path, whileInDocBlock);
}
this._docBlock = contentPromise
.then(docBlock => this._parseDocBlock(docBlock));
}
this._docBlock = this._fastfs.readWhile(this.path, whileInDocBlock)
.then(docBlock => {
const [id] = this._parseDocBlock(docBlock);
return {id};
});
return this._docBlock;
}
read() {
if (this._reading) {
return this._reading;
}
read(transformOptions) {
return this._cache.get(
this.path,
cacheKey('moduleData', transformOptions),
() => {
const fileContentPromise = this._fastfs.readFile(this.path);
return Promise.all([
fileContentPromise,
this._readDocBlock(fileContentPromise)
]).then(([code, {id, moduleDocBlock}]) => {
// Ignore requires in JSON files or generated code. An example of this
// is prebuilt files like the SourceMap library.
if (this.isJSON() || 'extern' in moduleDocBlock) {
return {id, code, dependencies: []};
} else {
const transformCode = this._transformCode;
const codePromise = transformCode
? transformCode(this, code, transformOptions)
: Promise.resolve({code});
this._reading = this._fastfs.readFile(this.path).then(content => {
const [id, moduleDocBlock] = this._parseDocBlock(content);
// Ignore requires in JSON files or generated code. An example of this
// is prebuilt files like the SourceMap library.
if (this.isJSON() || 'extern' in moduleDocBlock) {
return {
id,
dependencies: [],
code: content,
};
} else {
const transformCode = this._transformCode;
const codePromise = transformCode
? transformCode(this, content)
: Promise.resolve({code: content});
return codePromise.then(({code, dependencies}) => {
const {deps} = this._extractor(code);
return {
id,
code,
dependencies: dependencies || deps.sync,
};
});
return codePromise.then(({code, dependencies, map}) => {
if (!dependencies) {
dependencies = this._extractor(code).deps.sync;
}
return {id, code, dependencies, map};
});
}
})
}
});
return this._reading;
);
}
hash() {
@ -207,4 +202,38 @@ function whileInDocBlock(chunk, i, result) {
return !/\*\//.test(result);
}
// use weak map to speed up hash creation of known objects
const knownHashes = new WeakMap();
function stableObjectHash(object) {
let digest = knownHashes.get(object);
if (!digest) {
const hash = crypto.createHash('md5');
stableObjectHash.addTo(object, hash);
digest = hash.digest('base64');
knownHashes.set(object, digest);
}
return digest;
}
stableObjectHash.addTo = function addTo(value, hash) {
if (value === null || typeof value !== 'object') {
hash.update(JSON.stringify(value));
} else {
Object.keys(value).sort().forEach(key => {
const valueForKey = value[key];
if (valueForKey !== undefined) {
hash.update(key);
addTo(valueForKey, hash);
}
});
}
};
function cacheKey(field, transformOptions) {
return transformOptions !== undefined
? stableObjectHash(transformOptions) + '\0' + field
: field;
}
module.exports = Module;

92
packager/react-packager/src/DependencyResolver/__tests__/Module-test.js vendored
View File

@ -178,16 +178,10 @@ describe('Module', () => {
expect(code).toBe(fileContents))
);
pit('exposes file contes via the `getCode()` method', () =>
pit('exposes file contents via the `getCode()` method', () =>
createModule().getCode().then(code =>
expect(code).toBe(fileContents))
);
pit('does not save the code in the cache', () =>
createModule().getCode().then(() =>
expect(cache.get).not.toBeCalled()
)
);
});
describe('Extrators', () => {
@ -221,10 +215,19 @@ describe('Module', () => {
const module = createModule({transformCode});
return module.read()
.then(() => {
expect(transformCode).toBeCalledWith(module, fileContents);
expect(transformCode).toBeCalledWith(module, fileContents, undefined);
});
});
pit('passes any additional options to the transform function when reading', () => {
const module = createModule({transformCode});
const transformOptions = {arbitrary: Object()};
return module.read(transformOptions)
.then(() =>
expect(transformCode.mock.calls[0][2]).toBe(transformOptions)
);
});
pit('uses the code that `transformCode` resolves to to extract dependencies', () => {
transformCode.mockReturnValue(Promise.resolve({code: exampleCode}));
const module = createModule({transformCode});
@ -256,5 +259,78 @@ describe('Module', () => {
expect(code).toBe(exampleCode);
});
});
pit('exposes a source map returned by the transform', () => {
const map = {version: 3};
transformCode.mockReturnValue(Promise.resolve({map, code: exampleCode}));
const module = createModule({transformCode});
return Promise.all([module.read(), module.getMap()])
.then(([data, sourceMap]) => {
expect(data.map).toBe(map);
expect(sourceMap).toBe(map);
});
});
describe('Caching based on options', () => {
let module;
beforeEach(function() {
module = createModule({transformCode});
});
const callsEqual = ([path1, key1], [path2, key2]) => {
expect(path1).toEqual(path2);
expect(key1).toEqual(key2);
}
it('gets dependencies from the cache with the same cache key for the same transform options', () => {
const options = {some: 'options'};
module.getDependencies(options); // first call
module.getDependencies(options); // second call
const {calls} = cache.get.mock;
callsEqual(calls[0], calls[1]);
});
it('gets dependencies from the cache with the same cache key for the equivalent transform options', () => {
const options = {some: 'options'};
module.getDependencies({a: 'b', c: 'd'}); // first call
module.getDependencies({c: 'd', a: 'b'}); // second call
const {calls} = cache.get.mock;
callsEqual(calls[0], calls[1]);
});
it('gets dependencies from the cache with different cache keys for different transform options', () => {
module.getDependencies({some: 'options'});
module.getDependencies({other: 'arbitrary options'});
const {calls} = cache.get.mock;
expect(calls[0][1]).not.toEqual(calls[1][1]);
});
it('gets code from the cache with the same cache key for the same transform options', () => {
const options = {some: 'options'};
module.getCode(options); // first call
module.getCode(options); // second call
const {calls} = cache.get.mock;
callsEqual(calls[0], calls[1]);
});
it('gets code from the cache with the same cache key for the equivalent transform options', () => {
const options = {some: 'options'};
module.getCode({a: 'b', c: 'd'}); // first call
module.getCode({c: 'd', a: 'b'}); // second call
const {calls} = cache.get.mock;
callsEqual(calls[0], calls[1]);
});
it('gets code from the cache with different cache keys for different transform options', () => {
module.getCode({some: 'options'});
module.getCode({other: 'arbitrary options'});
const {calls} = cache.get.mock;
expect(calls[0][1]).not.toEqual(calls[1][1]);
});
});
});
});