unknownTracker -> unidentifiedTracker global replace

app/panel-android/actions/blockingActions.js

@@ -73,17 +73,17 @@ export function anonymizeSiteTracker({ actionData, state }) {
 	const updatedcliqzModuleData = JSON.parse(JSON.stringify(state.cliqzModuleData));
 	const { antiTracking, adBlock } = state.cliqzModuleData;
 	const whitelistedUrls = { ...antiTracking.whitelistedUrls, ...adBlock.whitelistedUrls };
-	const { unknownTracker } = actionData;
+	const { unidentifiedTracker } = actionData;
 	const { pageHost } = state.summary;
 
 	const addToWhitelist = () => {
-		unknownTracker.sources.forEach((domain) => {
+		unidentifiedTracker.sources.forEach((domain) => {
 			if (whitelistedUrls.hasOwnProperty(domain)) {
-				whitelistedUrls[domain].name = unknownTracker.name;
+				whitelistedUrls[domain].name = unidentifiedTracker.name;
 				whitelistedUrls[domain].hosts.push(pageHost);
 			} else {
 				whitelistedUrls[domain] = {
-					name: unknownTracker.name,
+					name: unidentifiedTracker.name,
 					hosts: [pageHost],
 				};
 			}
@@ -102,11 +102,11 @@ export function anonymizeSiteTracker({ actionData, state }) {
 		}
 	};
 
-	if (unknownTracker.whitelisted) {
-		unknownTracker.sources.forEach(removeFromWhitelist);
+	if (unidentifiedTracker.whitelisted) {
+		unidentifiedTracker.sources.forEach(removeFromWhitelist);
 
 		Object.keys(whitelistedUrls).forEach((domain) => {
-			if (whitelistedUrls[domain].name === unknownTracker.name) {
+			if (whitelistedUrls[domain].name === unidentifiedTracker.name) {
 				removeFromWhitelist(domain);
 			}
 		});
@@ -115,14 +115,14 @@ export function anonymizeSiteTracker({ actionData, state }) {
 	}
 
 	// Update Ad Blocking trackers
-	updatedcliqzModuleData.adBlock.unknownTrackers.forEach((trackerEl) => {
-		if (trackerEl.name === unknownTracker.name) {
+	updatedcliqzModuleData.adBlock.unidentifiedTrackers.forEach((trackerEl) => {
+		if (trackerEl.name === unidentifiedTracker.name) {
 			trackerEl.whitelisted = !trackerEl.whitelisted;
 		}
 	});
 	// Update Anti-Tracking trackers
-	updatedcliqzModuleData.antiTracking.unknownTrackers.forEach((trackerEl) => {
-		if (trackerEl.name === unknownTracker.name) {
+	updatedcliqzModuleData.antiTracking.unidentifiedTrackers.forEach((trackerEl) => {
+		if (trackerEl.name === unidentifiedTracker.name) {
 			trackerEl.whitelisted = !trackerEl.whitelisted;
 		}
 	});

app/panel-android/components/PanelAndroid.jsx

@@ -54,8 +54,8 @@ class PanelAndroid extends React.Component {
 				categories: [],
 			},
 			cliqzModuleData: {
-				adBlock: { trackerCount: 0, unknownTrackers: [] },
-				antiTracking: { trackerCount: 0, unknownTrackers: [] },
+				adBlock: { trackerCount: 0, unidentifiedTrackers: [] },
+				antiTracking: { trackerCount: 0, unidentifiedTrackers: [] },
 			},
 		};
 	}
@@ -207,9 +207,9 @@ class PanelAndroid extends React.Component {
 		const { categories, toggle_individual_trackers } = blocking;
 		const { adBlock, antiTracking } = cliqzModuleData;
 
-		const unknownTrackers = Array.from(new Set([
-			...antiTracking.unknownTrackers.map(this.massageCliqzTrackers),
-			...adBlock.unknownTrackers.map(this.massageCliqzTrackers),
+		const unidentifiedTrackers = Array.from(new Set([
+			...antiTracking.unidentifiedTrackers.map(this.massageCliqzTrackers),
+			...adBlock.unidentifiedTrackers.map(this.massageCliqzTrackers),
 		])).sort((a, b) => {
 			const nameA = a.name.toLowerCase();
 			const nameB = b.name.toLowerCase();
@@ -226,9 +226,9 @@ class PanelAndroid extends React.Component {
 			name: t('unidentified'),
 			description: t('unidentified_description'),
 			img_name: 'unknown',
-			num_total: unknownTrackers.length,
+			num_total: unidentifiedTrackers.length,
 			num_blocked: 0, // We don't want to see the Trackers Blocked text
-			trackers: unknownTrackers,
+			trackers: unidentifiedTrackers,
 		};
 
 		return (
@@ -248,7 +248,7 @@ class PanelAndroid extends React.Component {
 				<Tab tabLabel={t('android_tab_site_blocking')} linkClassName="Tab__label">
 					<BlockingTab
 						type="site"
-						categories={unknownTrackers.length === 0 ? categories : [...categories, unknownCategory]}
+						categories={unidentifiedTrackers.length === 0 ? categories : [...categories, unknownCategory]}
 						settings={{ toggle_individual_trackers }}
 						siteProps={this.siteProps}
 						callGlobalAction={this.callGlobalAction}

app/panel-android/components/content/BlockingTracker.jsx

@@ -177,7 +177,7 @@ class BlockingTracker extends React.Component {
 		callGlobalAction({
 			actionName: 'anonymizeSiteTracker',
 			actionData: {
-				unknownTracker: tracker,
+				unidentifiedTracker: tracker,
 			}
 		});
 	}

app/panel/actions/BlockingActions.js

@@ -123,13 +123,13 @@ export function updateTrackerTrustRestrict(data) {
  * @param  {Object} data
  * @return {Object} dispatch
  */
-export function updateCliqzModuleWhitelist(unknownTracker) {
+export function updateCliqzModuleWhitelist(unidentifiedTracker) {
 	return function(dispatch, getState) {
 		// use redux-thunk to get pageHost from summary
 		const { pageHost } = getState().summary;
 		dispatch({
 			type: UPDATE_CLIQZ_MODULE_WHITELIST,
-			data: { unknownTracker, pageHost },
+			data: { unidentifiedTracker, pageHost },
 		});
 	};
 }

app/panel/components/Blocking.jsx

@@ -349,7 +349,7 @@ class Blocking extends React.Component {
 					<NotScanned />
 				) : (
 					<div className={`${blockingClasses} blocking-trackers show-warnings`}>
-						{(categories.length > 0 || unknownCategory.unknownTrackers.length > 0) && (
+						{(categories.length > 0 || unknownCategory.unidentifiedTrackers.length > 0) && (
 							<Categories
 								expandAll={expand_all_trackers}
 								categories={categories}

app/panel/components/Blocking/Categories.jsx

@@ -56,25 +56,25 @@ class Categories extends React.Component {
 					name: t('unidentified'),
 					description: t('unidentified_description'),
 					img_name: 'unknown',
-					num_total: unknownCategory.unknownTrackers.length,
-					num_blocked: unknownCategory.unknownTrackerCount,
-					num_shown: unknownCategory.hide ? 0 : unknownCategory.unknownTrackers.length,
-					trackers: unknownCategory.unknownTrackers.map((unknownTracker) => {
-						if (unknownTracker.whitelisted) { whitelistedTotal++; }
+					num_total: unknownCategory.unidentifiedTrackers.length,
+					num_blocked: unknownCategory.unidentifiedTrackerCount,
+					num_shown: unknownCategory.hide ? 0 : unknownCategory.unidentifiedTrackers.length,
+					trackers: unknownCategory.unidentifiedTrackers.map((unidentifiedTracker) => {
+						if (unidentifiedTracker.whitelisted) { whitelistedTotal++; }
 						return {
-							name: unknownTracker.name,
-							domains: unknownTracker.domains,
-							whitelisted: unknownTracker.whitelisted,
-							type: unknownTracker.type,
+							name: unidentifiedTracker.name,
+							domains: unidentifiedTracker.domains,
+							whitelisted: unidentifiedTracker.whitelisted,
+							type: unidentifiedTracker.type,
 							siteRestricted: sitePolicy === 1,
 							blocked: false,
 							catId: 'unknown',
 							description: '',
-							id: unknownTracker.name + unknownTracker.domains[0],
+							id: unidentifiedTracker.name + unidentifiedTracker.domains[0],
 							shouldShow: true,
-							cliqzAdCount: unknownTracker.ads,
-							cliqzCookieCount: unknownTracker.cookies,
-							cliqzFingerprintCount: unknownTracker.fingerprints,
+							cliqzAdCount: unidentifiedTracker.ads,
+							cliqzCookieCount: unidentifiedTracker.cookies,
+							cliqzFingerprintCount: unidentifiedTracker.fingerprints,
 						};
 					}),
 					whitelistedTotal,
@@ -104,7 +104,7 @@ class Categories extends React.Component {
 		};
 
 		const categoryList = categories.map((category, index) => renderCategory(category, index));
-		const renderUnknownCategory = unknownCategory && unknownCategory.unknownTrackers.length
+		const renderUnknownCategory = unknownCategory && unknownCategory.unidentifiedTrackers.length
 			? renderCategory(null, categoryList.length, true) : null;
 
 		return (

app/panel/components/BuildingBlocks/DonutGraph.jsx

@@ -163,10 +163,10 @@ class DonutGraph extends React.Component {
 			return;
 		}
 
-		if (!prevAntiTracking.unknownTrackerCount && !antiTracking.unknownTrackerCount
-			&& !prevAdBlock.unknownTrackerCount && !adBlock.unknownTrackerCount) { return; }
-		const prevUnknownDataPoints = prevAntiTracking.unknownTrackerCount + prevAdBlock.unknownTrackerCount;
-		const unknownDataPoints = antiTracking.unknownTrackerCount + adBlock.unknownTrackerCount;
+		if (!prevAntiTracking.unidentifiedTrackerCount && !antiTracking.unidentifiedTrackerCount
+			&& !prevAdBlock.unidentifiedTrackerCount && !adBlock.unidentifiedTrackerCount) { return; }
+		const prevUnknownDataPoints = prevAntiTracking.unidentifiedTrackerCount + prevAdBlock.unidentifiedTrackerCount;
+		const unknownDataPoints = antiTracking.unidentifiedTrackerCount + adBlock.unidentifiedTrackerCount;
 		if (prevUnknownDataPoints !== unknownDataPoints) {
 			this.nextPropsDonut(this.props);
 		}
@@ -213,7 +213,7 @@ class DonutGraph extends React.Component {
 		} = options;
 		const graphData = [];
 		const animationDuration = categories.length > 0 ? 500 : 0;
-		const categoryCount = categories.length + antiTracking.unknownTrackerCount + adBlock.unknownTrackerCount;
+		const categoryCount = categories.length + antiTracking.unidentifiedTrackerCount + adBlock.unidentifiedTrackerCount;
 
 		// Process categories into graphData
 		if (categoryCount === 0) {
@@ -233,11 +233,11 @@ class DonutGraph extends React.Component {
 			graphData.sort((a, b) => a.value < b.value);
 		}
 
-		if (antiTracking.unknownTrackerCount || adBlock.unknownTrackerCount) {
+		if (antiTracking.unidentifiedTrackerCount || adBlock.unidentifiedTrackerCount) {
 			graphData.push({
 				id: 'unknown',
 				name: 'Unknown',
-				value: antiTracking.unknownTrackerCount + adBlock.unknownTrackerCount,
+				value: antiTracking.unidentifiedTrackerCount + adBlock.unidentifiedTrackerCount,
 			});
 		}
 
@@ -382,7 +382,7 @@ class DonutGraph extends React.Component {
 							{cat.name}
 						</span>
 					))}
-					{(!!antiTracking.unknownTrackerCount || !!adBlock.unknownTrackerCount) && (
+					{(!!antiTracking.unidentifiedTrackerCount || !!adBlock.unidentifiedTrackerCount) && (
 						<span
 							className="DonutGraph__tooltip tooltip top"
 							id="unknown_tooltip"
@@ -422,8 +422,8 @@ DonutGraph.propTypes = {
 
 DonutGraph.defaultProps = {
 	categories: [],
-	adBlock: { unknownTrackerCount: 0 },
-	antiTracking: { unknownTrackerCount: 0 },
+	adBlock: { unidentifiedTrackerCount: 0 },
+	antiTracking: { unidentifiedTrackerCount: 0 },
 	clickDonut: () => {},
 	isSmall: false,
 };

app/panel/components/BuildingBlocks/__tests__/DonutGraph.jsx

@@ -63,8 +63,8 @@ describe('app/panel/components/DonutGraph.jsx', () => {
 							num_total: 4
 						},
 					]}
-					adBlock={{ unknownTrackerCount: 8 }}
-					antiTracking={{ unknownTrackerCount: 8 }}
+					adBlock={{ unidentifiedTrackerCount: 8 }}
+					antiTracking={{ unidentifiedTrackerCount: 8 }}
 					renderRedscale
 					renderGreyscale={false}
 					totalCount={8}
@@ -101,8 +101,8 @@ describe('app/panel/components/DonutGraph.jsx', () => {
 							num_total: 4
 						},
 					]}
-					adBlock={{ unknownTrackerCount: 8 }}
-					antiTracking={{ unknownTrackerCount: 8 }}
+					adBlock={{ unidentifiedTrackerCount: 8 }}
+					antiTracking={{ unidentifiedTrackerCount: 8 }}
 					renderRedscale={false}
 					renderGreyscale
 					totalCount={38}

app/panel/reducers/__tests__/summary.js

@@ -39,16 +39,16 @@ const initialState = Immutable({
 		totalUnknownCount: 0,
 		totalUnsafeCount: 0,
 		trackerCount: 0,
-		unknownTrackerCount: 0,
-		unknownTrackers: [],
+		unidentifiedTrackerCount: 0,
+		unidentifiedTrackers: [],
 		whitelistedUrls: {},
 	},
 	adBlock: {
 		totalUnknownCount: 0,
 		totalUnsafeCount: 0,
 		trackerCount: 0,
-		unknownTrackerCount: 0,
-		unknownTrackers: [],
+		unidentifiedTrackerCount: 0,
+		unidentifiedTrackers: [],
 		whitelistedUrls: {},
 	},
 });

app/panel/reducers/blocking.js

@@ -44,8 +44,8 @@ const initialState = {
 		totalUnsafeCount: 0, // The amount of data points scrubbed by Anti-Tracking and Ad Block
 		totalUnknownCount: 0, // The amount of data points scrubbed by Anti-Tracking and Ad Block for Trackers not in the Ghostery DB
 		trackerCount: 0, // The amount of trackers scrubbed by Anti-Tracking and Ad Block (which are each associated with 1 or more data points)
-		unknownTrackerCount: 0, // The amount of unknown trackers scrubbed by Anti-Tracking and Ad Block
-		unknownTrackers: [], // An array of objects associated with each unknown Tracker (includes both blocked and whitelisted trackers for this site)
+		unidentifiedTrackerCount: 0, // The amount of unknown trackers scrubbed by Anti-Tracking and Ad Block
+		unidentifiedTrackers: [], // An array of objects associated with each unknown Tracker (includes both blocked and whitelisted trackers for this site)
 		whitelistedUrls: {}, // An object of whitelisted url domains pointing to an object with the associated tracker name and an array of whitelisted host domains
 		hide: false, // Whether or not to display the Unknown category
 	}
@@ -128,16 +128,16 @@ const _updateTrackerTrustRestrict = (state, action) => {
 const _updateCliqzModuleWhitelist = (state, action) => {
 	const updatedUnknownCategory = JSON.parse(JSON.stringify(state.unknownCategory));
 	const { whitelistedUrls } = updatedUnknownCategory;
-	const { unknownTracker, pageHost } = action.data;
+	const { unidentifiedTracker, pageHost } = action.data;
 
 	const addToWhitelist = () => {
-		unknownTracker.domains.forEach((domain) => {
+		unidentifiedTracker.domains.forEach((domain) => {
 			if (whitelistedUrls.hasOwnProperty(domain)) {
-				whitelistedUrls[domain].name = unknownTracker.name;
+				whitelistedUrls[domain].name = unidentifiedTracker.name;
 				whitelistedUrls[domain].hosts.push(pageHost);
 			} else {
 				whitelistedUrls[domain] = {
-					name: unknownTracker.name,
+					name: unidentifiedTracker.name,
 					hosts: [pageHost],
 				};
 			}
@@ -156,20 +156,20 @@ const _updateCliqzModuleWhitelist = (state, action) => {
 		}
 	};
 
-	if (unknownTracker.whitelisted) {
-		unknownTracker.domains.forEach(removeFromWhitelist);
+	if (unidentifiedTracker.whitelisted) {
+		unidentifiedTracker.domains.forEach(removeFromWhitelist);
 
 		Object.keys(whitelistedUrls).forEach((domain) => {
-			if (whitelistedUrls[domain].name === unknownTracker.name) {
+			if (whitelistedUrls[domain].name === unidentifiedTracker.name) {
 				removeFromWhitelist(domain);
 			}
 		});
 	} else {
 		addToWhitelist();
 	}
 
-	updatedUnknownCategory.unknownTrackers.forEach((trackerEl) => {
-		if (trackerEl.name === unknownTracker.name) {
+	updatedUnknownCategory.unidentifiedTrackers.forEach((trackerEl) => {
+		if (trackerEl.name === unidentifiedTracker.name) {
 			trackerEl.whitelisted = !trackerEl.whitelisted;
 		}
 	});
@@ -237,8 +237,8 @@ export default (state = initialState, action) => {
 					totalUnsafeCount: antiTracking.totalUnsafeCount + adBlock.totalUnsafeCount,
 					totalUnknownCount: antiTracking.totalUnknownCount + adBlock.totalUnknownCount,
 					trackerCount: antiTracking.trackerCount + adBlock.trackerCount,
-					unknownTrackerCount: antiTracking.unknownTrackerCount + adBlock.unknownTrackerCount,
-					unknownTrackers: Array.from(new Set(antiTracking.unknownTrackers.concat(adBlock.unknownTrackers))),
+					unidentifiedTrackerCount: antiTracking.unidentifiedTrackerCount + adBlock.unidentifiedTrackerCount,
+					unidentifiedTrackers: Array.from(new Set(antiTracking.unidentifiedTrackers.concat(adBlock.unidentifiedTrackers))),
 					whitelistedUrls: { ...antiTracking.whitelistedUrls, ...adBlock.whitelistedUrls },
 					hide: state.unknownCategory.hide,
 				};

app/panel/reducers/summary.js

@@ -39,16 +39,16 @@ const initialState = {
 		totalUnknownCount: 0, // The amount of data points scrubbed by Anti-Tracking for Trackers not in the Ghostery DB
 		totalUnsafeCount: 0, // The amount of data points scrubbed by Anti-Tracking
 		trackerCount: 0, // The amount of trackers scrubbed by Anti-Tracking (which are each associated with 1 or more data points)
-		unknownTrackerCount: 0, // The amount of unknown trackers scrubbed by Anti-Tracking
-		unknownTrackers: [], // List of anti-tracking trackers not matched to Ghostery bug IDs
+		unidentifiedTrackerCount: 0, // The amount of unknown trackers scrubbed by Anti-Tracking
+		unidentifiedTrackers: [], // List of anti-tracking trackers not matched to Ghostery bug IDs
 		whitelistedUrls: {},
 	},
 	adBlock: {
 		totalUnknownCount: 0, // The amount of data points blocked by Ad Blocking for Trackers not in the Ghostery DB
 		totalUnsafeCount: 0, // The amount of data points blocked by Ad Blocking
 		trackerCount: 0, // The amount of trackers blocked by Ad Blocking (which are each associated with 1 or more ads)
-		unknownTrackerCount: 0, // The amount of unknown trackers blocked by Ad Blocking
-		unknownTrackers: [], // List of ad-block trackers not matched to Ghostery bug IDs
+		unidentifiedTrackerCount: 0, // The amount of unknown trackers blocked by Ad Blocking
+		unidentifiedTrackers: [], // List of ad-block trackers not matched to Ghostery bug IDs
 		whitelistedUrls: {},
 	}
 };