2017

pending completion

Build # 2017

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #309 from eweitz/gene-structure-tooltips

Show gene structure diagrams in tooltips

Run Details

1459 of 1903 branches covered (76.67%)

Branch coverage included in aggregate %.

160 of 160 new or added lines in 4 files covered. (100.0%)

4094 of 4585 relevant lines covered (89.29%)

36822.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

30.25

/src/js/gene-structure-cache.js

/**
 * @fileoverview Fetch cached gene structure data: transcript, subparts, etc.
 *
 * Gene structure cache eliminates needing to fetch features of genes from
 * third-party APIs at runtime.  It achieves this by fetching a static file
 * containing gene structure data upon initializing Ideogram.
 *
 * Use cases:
 *
 * - show gene's canonical Ensembl transcript, including its UTRs and exons
 */
import {decompressSync, strFromU8} from 'fflate';

import {slug, getEarlyTaxid, getDir} from './lib';
import {organismMetadata} from './init/organism-metadata';
import version from './version';

let perfTimes;

/** Get URL for gene structure cache file */
function getCacheUrl(orgName, cacheDir) {
  const organism = slug(orgName);
  if (!cacheDir) {
    cacheDir = getDir('cache/');
  }
  cacheDir += 'gene-structures/';

  const cacheUrl = cacheDir + organism + '-gene-structures.tsv.gz';

  return cacheUrl;
}

/** Parse compressed feature subparts to more easily computable format */
function deserializeSubparts(rawSubparts, subpartKeys) {
  const subparts = [];
  for (let i = 0; i < rawSubparts.length; i++) {
    const rawSubpart = rawSubparts[i].split(';');
    const subpartType = subpartKeys[parseInt(rawSubpart[0])];
    const start = parseInt(rawSubpart[1]);
    const length = parseInt(rawSubpart[2]);
    const subpart = [subpartType, start, length];
    subparts.push(subpart);
  }
  return subparts;
}

const biotypes = ['protein coding', 'foo', 'bar'];

function parseMetainformationHeader(line) {
  const splitHead = line.split(' keys: ');
  if (splitHead.length < 2) return [null];
  const metaHeader = splitHead[0].split('## ')[1];
  const keys = {};
  splitHead[1].split(', ').forEach(entry => {
    const splitEntry = entry.split(' = ');
    keys[splitEntry[0]] = splitEntry[1];
  });
  return [metaHeader, keys];
}

/** Parse a gene structure cache TSV file, return array of useful transforms */
function parseCache(rawTsv) {
  const featuresByGene = {};

  let t0 = performance.now();
  const lines = rawTsv.split(/\r\n|\n/);
  perfTimes.rawTsvSplit = Math.round(performance.now() - t0);

  let biotypeKeys, subpartKeys;

  t0 = performance.now();
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    if (line === '') continue; // Skip empty lines
    if (line[0] === '#') {
      if (line[1] === '#') {
        const [metaHeader, keys] = parseMetainformationHeader(line);
        if (metaHeader === 'biotype') {
          biotypeKeys = keys;
        } else if (metaHeader === 'subpart') {
          subpartKeys = keys;
        }
      }
      continue;
    }
    const splitLine = line.trim().split(/\t/);

    const [
      transcriptName, biotypeCompressed, strand
    ] = splitLine.slice(0, 3);

    const gene = transcriptName.split('-').slice(0, -1).join('-');

    const rawSubparts = splitLine.slice(3);
    const subparts = deserializeSubparts(rawSubparts, subpartKeys);

    const biotype = biotypeKeys[biotypeCompressed];

    const feature = {
      transcriptName,
      biotype,
      strand,
      subparts
    };

    featuresByGene[gene] = feature;
  };
  const t1 = performance.now();
  perfTimes.parseCacheLoop = Math.round(t1 - t0);

  return featuresByGene;
}

/** Get organism's metadata fields */
function parseOrgMetadata(orgName) {
  const taxid = getEarlyTaxid(orgName);
  return organismMetadata[taxid] || {};
}

/** Reports if current organism has a gene structure cache */
function hasGeneStructureCache(orgName) {
  const metadata = parseOrgMetadata(orgName);
  return (
    metadata.hasGeneStructureCache &&
    metadata.hasGeneStructureCache === true
  );
}

export async function cacheFetch(url) {

  const decompressedUrl = url.replace('.gz', '');
  const response = await Ideogram.cache.match(decompressedUrl);
  if (typeof response === 'undefined') {
    // If cache miss, then fetch and add response to cache
    // await Ideogram.cache.add(url);
    const rawResponse = await fetch(url);
    const blob = await rawResponse.blob();
    const uint8Array = new Uint8Array(await blob.arrayBuffer());
    const data = strFromU8(decompressSync(uint8Array));
    const decompressedResponse = new Response(
      new Blob([data], {type: 'text/tab-separated-values'}),
      rawResponse.init
    );
    await Ideogram.cache.put(decompressedUrl, decompressedResponse);
    return await Ideogram.cache.match(decompressedUrl);
  }
  return await Ideogram.cache.match(decompressedUrl);
}

/**
* Fetch cached gene data, transform it usefully, and set it as ideo prop
*/
export default async function initGeneStructureCache(
  orgName, ideo, cacheDir=null
) {

  const startTime = performance.now();
  perfTimes = {};

  // Skip initialization if files needed to make cache don't exist
  if (!hasGeneStructureCache(orgName)) return;

  // Skip initialization if cache is already populated
  if (Ideogram.geneStructureCache && Ideogram.geneStructureCache[orgName]) {
    // Simplify chief use case, i.e. for single organism
    ideo.geneStructureCache = Ideogram.geneStructureCache[orgName];
    return;
  }

  if (!Ideogram.geneStructureCache) {
    Ideogram.geneStructureCache = {};
  }

  Ideogram.cache = await caches.open(`ideogram-${version}`);

  const cacheUrl = getCacheUrl(orgName, cacheDir, ideo);

  const fetchStartTime = performance.now();
  const response = await cacheFetch(cacheUrl);

  const data = await response.text();
  const fetchEndTime = performance.now();
  perfTimes.fetch = Math.round(fetchEndTime - fetchStartTime);

  const featuresByGene = parseCache(data);
  perfTimes.parseCache = Math.round(performance.now() - fetchEndTime);

  ideo.geneStructureCache = featuresByGene;
  Ideogram.geneStructureCache[orgName] = ideo.geneStructureCache;

  if (ideo.config.debug) {
    perfTimes.total = Math.round(performance.now() - startTime);
    console.log('perfTimes in initGeneStructureCache:', perfTimes);
  }
}

1	/**
2	* @fileoverview Fetch cached gene structure data: transcript, subparts, etc.
3	*
4	* Gene structure cache eliminates needing to fetch features of genes from
5	* third-party APIs at runtime. It achieves this by fetching a static file
6	* containing gene structure data upon initializing Ideogram.
7	*
8	* Use cases:
9	*
10	* - show gene's canonical Ensembl transcript, including its UTRs and exons
11	*/
12	import {decompressSync, strFromU8} from 'fflate';
13
14	import {slug, getEarlyTaxid, getDir} from './lib';
15	import {organismMetadata} from './init/organism-metadata';
16	import version from './version';
17
18	let perfTimes;
19
20	/** Get URL for gene structure cache file */
21	function getCacheUrl(orgName, cacheDir) {
22	const organism = slug(orgName);	1✔
23	if (!cacheDir) {	1!
24	cacheDir = getDir('cache/');	×
25	}
26	cacheDir += 'gene-structures/';	1✔
27
28	const cacheUrl = cacheDir + organism + '-gene-structures.tsv.gz';	1✔
29
30	return cacheUrl;	1✔
31	}
32
33	/** Parse compressed feature subparts to more easily computable format */
34	function deserializeSubparts(rawSubparts, subpartKeys) {
35	const subparts = [];	×
36	for (let i = 0; i < rawSubparts.length; i++) {	×
37	const rawSubpart = rawSubparts[i].split(';');	×
38	const subpartType = subpartKeys[parseInt(rawSubpart[0])];	×
39	const start = parseInt(rawSubpart[1]);	×
40	const length = parseInt(rawSubpart[2]);	×
41	const subpart = [subpartType, start, length];	×
42	subparts.push(subpart);	×
43	}
44	return subparts;	×
45	}
46
47	const biotypes = ['protein coding', 'foo', 'bar'];	1✔
48
49	function parseMetainformationHeader(line) {
50	const splitHead = line.split(' keys: ');	×
51	if (splitHead.length < 2) return [null];	×
52	const metaHeader = splitHead[0].split('## ')[1];	×
53	const keys = {};	×
54	splitHead[1].split(', ').forEach(entry => {	×
55	const splitEntry = entry.split(' = ');	×
56	keys[splitEntry[0]] = splitEntry[1];	×
57	});
58	return [metaHeader, keys];	×
59	}
60
61	/** Parse a gene structure cache TSV file, return array of useful transforms */
62	function parseCache(rawTsv) {
63	const featuresByGene = {};	×
64
65	let t0 = performance.now();	×
66	const lines = rawTsv.split(/\r\n\|\n/);	×
67	perfTimes.rawTsvSplit = Math.round(performance.now() - t0);	×
68
69	let biotypeKeys, subpartKeys;
70
71	t0 = performance.now();	×
72	for (let i = 0; i < lines.length; i++) {	×
73	const line = lines[i];	×
74	if (line === '') continue; // Skip empty lines	×
75	if (line[0] === '#') {	×
76	if (line[1] === '#') {	×
77	const [metaHeader, keys] = parseMetainformationHeader(line);	×
78	if (metaHeader === 'biotype') {	×
79	biotypeKeys = keys;	×
80	} else if (metaHeader === 'subpart') {	×
81	subpartKeys = keys;	×
82	}
83	}
84	continue;	×
85	}
86	const splitLine = line.trim().split(/\t/);	×
87
88	const [
89	transcriptName, biotypeCompressed, strand
90	] = splitLine.slice(0, 3);	×
91
92	const gene = transcriptName.split('-').slice(0, -1).join('-');	×
93
94	const rawSubparts = splitLine.slice(3);	×
95	const subparts = deserializeSubparts(rawSubparts, subpartKeys);	×
96
97	const biotype = biotypeKeys[biotypeCompressed];	×
98
99	const feature = {	×
100	transcriptName,
101	biotype,
102	strand,
103	subparts
104	};
105
106	featuresByGene[gene] = feature;	×
107	};
108	const t1 = performance.now();	×
109	perfTimes.parseCacheLoop = Math.round(t1 - t0);	×
110
111	return featuresByGene;	×
112	}
113
114	/** Get organism's metadata fields */
115	function parseOrgMetadata(orgName) {
116	const taxid = getEarlyTaxid(orgName);	1✔
117	return organismMetadata[taxid] \|\| {};	1!
118	}
119
120	/** Reports if current organism has a gene structure cache */
121	function hasGeneStructureCache(orgName) {
122	const metadata = parseOrgMetadata(orgName);	1✔
123	return (	1✔
124	metadata.hasGeneStructureCache &&	2✔
125	metadata.hasGeneStructureCache === true
126	);
127	}
128
129	export async function cacheFetch(url) {
130
131	const decompressedUrl = url.replace('.gz', '');	1✔
132	const response = await Ideogram.cache.match(decompressedUrl);	1✔
133	if (typeof response === 'undefined') {	1!
134	// If cache miss, then fetch and add response to cache
135	// await Ideogram.cache.add(url);
136	const rawResponse = await fetch(url);	1✔
137	const blob = await rawResponse.blob();	1✔
138	const uint8Array = new Uint8Array(await blob.arrayBuffer());	1✔
139	const data = strFromU8(decompressSync(uint8Array));	1✔
140	const decompressedResponse = new Response(	×
141	new Blob([data], {type: 'text/tab-separated-values'}),
142	rawResponse.init
143	);
144	await Ideogram.cache.put(decompressedUrl, decompressedResponse);	×
145	return await Ideogram.cache.match(decompressedUrl);	×
146	}
147	return await Ideogram.cache.match(decompressedUrl);	×
148	}
149
150	/**
151	* Fetch cached gene data, transform it usefully, and set it as ideo prop
152	*/
153	export default async function initGeneStructureCache(
154	orgName, ideo, cacheDir=null	×
155	) {
156
157	const startTime = performance.now();	1✔
158	perfTimes = {};	1✔
159
160	// Skip initialization if files needed to make cache don't exist
161	if (!hasGeneStructureCache(orgName)) return;	1!
162
163	// Skip initialization if cache is already populated
164	if (Ideogram.geneStructureCache && Ideogram.geneStructureCache[orgName]) {	1!
165	// Simplify chief use case, i.e. for single organism
166	ideo.geneStructureCache = Ideogram.geneStructureCache[orgName];	×
167	return;	×
168	}
169
170	if (!Ideogram.geneStructureCache) {	1!
171	Ideogram.geneStructureCache = {};	1✔
172	}
173
174	Ideogram.cache = await caches.open(`ideogram-${version}`);	1✔
175
176	const cacheUrl = getCacheUrl(orgName, cacheDir, ideo);	1✔
177
178	const fetchStartTime = performance.now();	1✔
179	const response = await cacheFetch(cacheUrl);	1✔
180
181	const data = await response.text();	×
182	const fetchEndTime = performance.now();	×
183	perfTimes.fetch = Math.round(fetchEndTime - fetchStartTime);	×
184
185	const featuresByGene = parseCache(data);	×
186	perfTimes.parseCache = Math.round(performance.now() - fetchEndTime);	×
187
188	ideo.geneStructureCache = featuresByGene;	×
189	Ideogram.geneStructureCache[orgName] = ideo.geneStructureCache;	×
190
191	if (ideo.config.debug) {	×
192	perfTimes.total = Math.round(performance.now() - startTime);	×
193	console.log('perfTimes in initGeneStructureCache:', perfTimes);	×
194	}
195	}

eweitz / ideogram / 2017

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous