3109

Build # 3109

Build Type

push

travis-ci

Committed by CodeGit

Commit Message

Merge branch 'is_reference_merge' into proteome_is_reference_filter

# Conflicts:
#	package-lock.json

Run Details

491 of 4705 branches covered (10.44%)

Branch coverage included in aggregate %.

315 of 315 new or added lines in 78 files covered. (100.0%)

992 of 9000 relevant lines covered (11.02%)

5.32 hits per line

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

0.0

/src/components/IPScan/EntrySubPage/index.js

import React, { PureComponent } from 'react';
import T from 'prop-types';
import { connect } from 'react-redux';
import { createSelector } from 'reselect';
import { flattenDeep } from 'lodash-es';

import { _RelatedAdvanced as Related } from 'components/Related';
import Loading from 'components/SimpleCommonComponents/Loading';
import Redirect from 'components/generic/Redirect';

import { descriptionSelector } from 'reducers/custom-location/description';

/*:: type Props = {
  data: Object,
  entryDB: entry,
}*/

const flatMatchesFromIPScanPayload = function*(ipScanMatches, proteinLength) {
  const protein = { protein: { length: proteinLength } };
  for (const match of ipScanMatches) {
    if (match.signature.entry) {
      yield {
        accession: match.signature.entry.accession,
        name: match.signature.entry.name,
        source_database: 'InterPro',
        entry_protein_locations: match.locations.map(location => ({
          fragments: [location],
        })),
        match: protein,
      };
    }
    yield {
      accession: match['model-ac'],
      name: match.signature.name,
      source_database: match.signature.signatureLibraryRelease.library,
      entry_protein_locations: match.locations.map(location => ({
        fragments: [location],
      })),
      match: protein,
    };
  }
};

const mergeEntries = matches => {
  const map = new Map();
  for (const match of matches) {
    let _match = map.get(match.accession);
    if (_match) {
      _match.entry_protein_locations = [
        ..._match.entry_protein_locations,
        ...match.entry_protein_locations,
      ];
    }
    map.set(match.accession, _match || match);
  }
  return Array.from(map.values());
};

class EntrySubPage extends PureComponent /*:: <Props> */ {
  static propTypes = {
    data: T.object.isRequired,
    entryDB: T.string.isRequired,
  };

  render() {
    const {
      entryDB,
      data: { payload },
    } = this.props;
    if (!entryDB)
      return (
        <Redirect
          to={customLocation => ({
            ...customLocation,
            description: {
              ...customLocation.description,
              entry: { isFilter: true, db: 'InterPro' },
            },
          })}
        />
      );
    if (!payload) return <Loading />;
    const mainData = { ...payload.results[0] };
    mainData.length = mainData.sequence.length;
    const flatArray = Array.from(
      flatMatchesFromIPScanPayload(mainData.matches, mainData.length),
    );
    const filtered = flatArray.filter(
      ({ source_database }) =>
        source_database.toLowerCase() === entryDB.toLowerCase(),
    );
    const unique = mergeEntries(filtered);
    return (
      <Related
        mainData={mainData}
        secondaryData={unique}
        isStale={false}
        mainType="protein"
        focusType="entry"
        focusDB={entryDB}
        actualSize={unique.length}
      />
    );
  }
}

const mapStateToProps = createSelector(descriptionSelector, description => ({
  entryDB: description.entry.db,
}));

export default connect(mapStateToProps)(EntrySubPage);

1	import React, { PureComponent } from 'react';	×
2	import T from 'prop-types';	×
3	import { connect } from 'react-redux';	×
4	import { createSelector } from 'reselect';	×
5	import { flattenDeep } from 'lodash-es';	×
6
7	import { _RelatedAdvanced as Related } from 'components/Related';	×
8	import Loading from 'components/SimpleCommonComponents/Loading';	×
9	import Redirect from 'components/generic/Redirect';	×
10
11	import { descriptionSelector } from 'reducers/custom-location/description';	×
12
13	/*:: type Props = {
14	data: Object,
15	entryDB: entry,
16	}*/
17
18	const flatMatchesFromIPScanPayload = function*(ipScanMatches, proteinLength) {	×
19	const protein = { protein: { length: proteinLength } };	×
20	for (const match of ipScanMatches) {	×
21	if (match.signature.entry) {	×
22	yield {	×
23	accession: match.signature.entry.accession,
24	name: match.signature.entry.name,
25	source_database: 'InterPro',
26	entry_protein_locations: match.locations.map(location => ({	×
27	fragments: [location],
28	})),
29	match: protein,
30	};
31	}
32	yield {	×
33	accession: match['model-ac'],
34	name: match.signature.name,
35	source_database: match.signature.signatureLibraryRelease.library,
36	entry_protein_locations: match.locations.map(location => ({	×
37	fragments: [location],
38	})),
39	match: protein,
40	};
41	}
42	};
43
44	const mergeEntries = matches => {	×
45	const map = new Map();	×
46	for (const match of matches) {	×
47	let _match = map.get(match.accession);	×
48	if (_match) {	×
49	_match.entry_protein_locations = [	×
50	..._match.entry_protein_locations,
51	...match.entry_protein_locations,
52	];
53	}
54	map.set(match.accession, _match \|\| match);	×
55	}
56	return Array.from(map.values());	×
57	};
58
59	class EntrySubPage extends PureComponent /:: <Props> / {
60	static propTypes = {
61	data: T.object.isRequired,
62	entryDB: T.string.isRequired,
63	};
64
65	render() {
66	const {
67	entryDB,
68	data: { payload },
69	} = this.props;	×
70	if (!entryDB)	×
71	return (	×
72	<Redirect
73	to={customLocation => ({	×
74	...customLocation,
75	description: {
76	...customLocation.description,
77	entry: { isFilter: true, db: 'InterPro' },
78	},
79	})}
80	/>
81	);
82	if (!payload) return <Loading />;	×
83	const mainData = { ...payload.results[0] };	×
84	mainData.length = mainData.sequence.length;	×
85	const flatArray = Array.from(	×
86	flatMatchesFromIPScanPayload(mainData.matches, mainData.length),
87	);
88	const filtered = flatArray.filter(	×
89	({ source_database }) =>
90	source_database.toLowerCase() === entryDB.toLowerCase(),	×
91	);
92	const unique = mergeEntries(filtered);	×
93	return (	×
94	<Related
95	mainData={mainData}
96	secondaryData={unique}
97	isStale={false}
98	mainType="protein"
99	focusType="entry"
100	focusDB={entryDB}
101	actualSize={unique.length}
102	/>
103	);
104	}
105	}
106
107	const mapStateToProps = createSelector(descriptionSelector, description => ({	×
108	entryDB: description.entry.db,
109	}));
110
111	export default connect(mapStateToProps)(EntrySubPage);

ProteinsWebTeam / interpro7-client / 3109

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