//Forked from [[User:Novem Linguae/Scripts/DetectPromo.js]]
//now highlights the words in the article text and those in the top bar are now clickable
// <nowiki>
/*
- Let reviewer know when certain promotional and POV keywords are detected.
- Displays a bar at the top of the article, listing the detected keywords.
- Highlights detected promotional words with a yellow background and red border within the article text.
- Makes the words in the top bar clickable, scrolling to their first occurrence in the article.
- Added "Report false positive" link to allow users to report incorrect detections.
- Added confirmation dialog explaining false positive criteria before reporting.
- Ignores promotional words that appear in the page title.
- Ignores promotional words that appear in wiki link titles.
*/
class DetectPromo {
/** @type {string[]} */
wordsToSearch = [
'% growth', '6-figure', '7-figure', '8-figure', '9-figure',
'B2B', 'B2C', 'a record', 'acclaimed', 'accomplished',
'are a necessity', 'around the world', 'award winning', 'award-winning',
'beloved', 'best available', 'bestselling', 'boasts', 'comprehensive',
'countless hours', 'create a revolution', 'critical acclaim',
'disrupt', 'drastically', 'dynamic', 'elevate', 'eminent', 'engaging',
'entrepreneur', 'evangelist', 'excelled', 'exceptional', 'exemplified',
'exemplify', 'expert', 'expertise', 'extensive', 'famous', 'fascinating',
'fast growing', 'fast-growing', 'fastest growing', 'fastest-growing',
'finest', 'fully integrated', 'fully-integrated', 'globally',
'globally recognized', 'growing popularity', 'highlights',
'highly accomplished', 'highly praised', 'highly specialized',
'historic', 'honored with', 'hypnotic', 'illustrious', 'impressive',
'indelible', 'inexhaustible', 'influential', 'innovation', 'innovative',
'insights', 'inspired by', 'integrate', 'invaluable', 'leader in',
'leading', 'legendary', 'leverage', 'massive', 'mastermind', 'more than',
'most highly', 'most important', 'most impressive', 'most notable',
'mystical', 'natural charm', 'noteworthy', 'numerous', 'organically',
'outstanding', 'perfect', 'philanthropist', 'picturesque', 'pioneer',
'pioneering', 'popular destination', 'popularity', 'premiere',
'prestigious', 'prominence', 'prominent', 'promising', 'promulgator',
'ranked', 'reinvent', 'remarkable', 'renowed', 'renowned', 'resonating',
'respected', 'revolutionary', 'rising star', 'save millions', 'savvy',
'seamless', 'sensual', 'several offers', 'showcased', 'signature',
'significant', 'soulful', 'spanning', 'state of art', 'state of the art',
'state-of-art', 'state-of-the-art', 'striking', 'super famous',
'tailored', 'tranquility', 'transcend', 'transform', 'underpin',
'ventured into', 'very first', 'visionary', 'wide selection',
'widely used', 'world class', 'world-class', 'worldwide', 'zero to hero'
];
/**
* Lists of allowed exception phrases - these will NOT be flagged even if they contain a listed word
* Key is the base word, value is an array of exception phrases
* @type {Object<string, string[]>}
*/
exceptionPhrases = {
'outstanding': ['outstanding debts'],
'drastically': ['vary drastically'],
'revolutionary': ['revolutionary war'],
'revolutionary': ['American revolutionary'],
'Revolutionary': ['Revolutionary Committee'],
'dynamic': ['dynamic list'],
'inspired': ['inspired by'],
'leading': ['leading to'],
'outstanding': ['outstanding warrant'],
'numerous': ['numerous witnesses'],
'significant': ['significant blow'],
'historic': ['National Register of Historic Places']
};
/**
* @param {Object} mw
* @param {jQuery} $
*/
constructor(mw, $) {
this.mw = mw;
this.$ = $;
// Store page title for later use
this.pageTitle = this.mw.config.get('wgTitle');
this.pageName = this.mw.config.get('wgPageName');
// Convert to lowercase for case-insensitive comparison
this.pageTitleLower = this.pageTitle.toLowerCase();
// Pre-process the words list for more efficient matching
this.processWordsList();
}
/**
* Process words list to identify base words for exception checking
*/
processWordsList() {
// Create a mapping of base words to their searchable variations
this.baseWordMap = {};
// For each searchable word, find if it has a base word with exceptions
for (const word of this.wordsToSearch) {
for (const baseWord in this.exceptionPhrases) {
// If the word contains the base word, map it back
if (word.toLowerCase().includes(baseWord.toLowerCase())) {
if (!this.baseWordMap[word.toLowerCase()]) {
this.baseWordMap[word.toLowerCase()] = [];
}
this.baseWordMap[word.toLowerCase()].push(baseWord.toLowerCase());
}
}
}
}
async execute() {
if (!this.shouldRunOnThisPage()) {
return;
}
const title = this.mw.config.get('wgPageName');
const wikicode = await this.getWikicode(title);
if (!wikicode) return;
// Clean wikicode by removing links and references
const cleanedWikicode = this.cleanWikicode(wikicode);
const searchResults = this.getSearchResults(cleanedWikicode);
if (searchResults.length > 0) {
this.displayResults(searchResults);
this.highlightPromoWords(searchResults);
}
}
/**
* @param {string[]} searchResults
*/
displayResults(searchResults) {
const MAX_DISPLAYED_RESULTS = 20;
const displayedResults = searchResults.slice(0, MAX_DISPLAYED_RESULTS);
let html = `
<div id="DetectPromo" style="background-color: #ccc; padding: 10px; margin-bottom: 10px; display: flex; justify-content: space-between; align-items: center;">
<div>
<span style="font-weight: bold;">Potentially promotional words detected:</span>
`;
html += displayedResults.map(word =>
`<a href="#" class="promo-word" data-word="${word}" style="color: blue; text-decoration: underline; cursor: pointer;">${word}</a>`
).join(', ');
if (searchResults.length > MAX_DISPLAYED_RESULTS) {
html += ', ...... and more.';
}
html += `</div>
<div>
<a href="#" id="report-false-positive" style="color: #d33; text-decoration: underline; font-size: 0.9em;">Report false positive</a>
</div>
</div>`;
this.$('#contentSub').after(html);
// Add click event listeners for promo words
this.$('.promo-word').on('click', (e) => {
e.preventDefault();
const word = this.$(e.target).data('word');
this.scrollToWord(word);
});
// Add click event listener for false positive reporting
this.$('#report-false-positive').on('click', (e) => {
e.preventDefault();
this.showFalsePositiveDialog(searchResults);
});
}
/**
* Scroll to the first occurrence of a word in the article
* @param {string} word
*/
scrollToWord(word) {
const content = this.$('#mw-content-text');
const regex = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'i');
const elements = content.find('*').contents().filter(function() {
return this.nodeType === Node.TEXT_NODE && regex.test(this.textContent);
});
if (elements.length > 0) {
const firstOccurrence = elements[0];
firstOccurrence.parentElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
}
}
/**
* Highlight promotional words with yellow background and red border within the article text
* @param {string[]} searchResults
*/
highlightPromoWords(searchResults) {
const content = this.$('#mw-content-text');
const highlightStyle = 'background-color: yellow; border: 1px solid red; padding: 2px; margin: -2px;';
searchResults.forEach(word => {
const regex = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'gi');
content.find('*').contents().filter(function() {
return this.nodeType === Node.TEXT_NODE;
}).each((_, textNode) => {
const text = textNode.textContent;
if (regex.test(text)) {
const newHtml = text.replace(regex, `<span class="promo-highlight" data-word="${word}" style="${highlightStyle}">$&</span>`);
const newElement = document.createElement('span');
newElement.innerHTML = newHtml;
textNode.parentNode.replaceChild(newElement, textNode);
}
});
});
}
/**
* Check if a word appears in the page title
* @param {string} word - The word to check
* @return {boolean} - True if the word is in the page title
*/
isWordInPageTitle(word) {
const wordLower = word.toLowerCase();
// Simple check for exact word in title
if (this.pageTitleLower.includes(wordLower)) {
// Check with word boundaries to ensure it's a complete word
const wordRegex = new RegExp(`\\b${this.escapeRegEx(wordLower)}\\b`, 'i');
return wordRegex.test(this.pageTitleLower);
}
return false;
}
/**
* Scans text for promotional words while respecting exceptions
* @param {string} text - The wikicode text to search
* @return {string[]} - List of found promotional words
*/
getSearchResults(text) {
const results = [];
const lowerText = text.toLowerCase();
// For each word to search
for (const word of this.wordsToSearch) {
const lowerWord = word.toLowerCase();
// Check if this word is in the text (quick filter)
if (!lowerText.includes(lowerWord)) {
continue;
}
// Test with proper word boundaries
const wordRegex = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'i');
if (!wordRegex.test(text)) {
continue;
}
// Check if word is in page title
if (this.isWordInPageTitle(word)) {
continue; // Skip this word if it's in the page title
}
// See if this word has any base words with exceptions
const baseWords = this.baseWordMap[lowerWord] || [];
// Check if this is an exact match for an exception phrase
let isException = false;
for (const baseWord of baseWords) {
const exceptionList = this.exceptionPhrases[baseWord] || [];
for (const exceptionPhrase of exceptionList) {
// If this word is part of an exception phrase that exists in the text, flag it
if (exceptionPhrase.toLowerCase() === lowerWord ||
(lowerText.includes(exceptionPhrase.toLowerCase()) &&
new RegExp(`\\b${this.escapeRegEx(exceptionPhrase)}\\b`, 'i').test(text))) {
isException = true;
break;
}
}
if (isException) break;
}
// Add it to results if it's not an exception
if (!isException) {
results.push(word);
}
}
return results;
}
/**
* Clean wikicode by removing links and references
* This focuses on removing wikilinks to avoid detecting promotional words
* within link targets/titles
*
* @param {string} wikicode
* @return {string} cleanedWikicode
*/
cleanWikicode(wikicode) {
// First, remove all wikilinks while keeping display text
let cleanedCode = wikicode.replace(/\[\[([^\]\|]+)\|([^\]]+)\]\]/g, '$2');
// Then, remove all simple wikilinks
cleanedCode = cleanedCode.replace(/\[\[([^\]]+)\]\]/g, '$1');
// Remove <ref> tags
cleanedCode = cleanedCode.replace(/<ref[^<]*<\/ref>|<ref[^>]*\/>/gm, '');
return cleanedCode;
}
/**
* @return {boolean}
*/
shouldRunOnThisPage() {
const action = this.mw.config.get('wgAction');
const isDiff = this.mw.config.get('wgDiffNewId');
const isDeletedPage = !this.mw.config.get('wgCurRevisionId');
const namespace = this.mw.config.get('wgNamespaceNumber');
const title = this.mw.config.get('wgPageName');
return (
action === 'view' &&
!isDiff &&
!isDeletedPage &&
([0, 118].includes(namespace) ||
title === 'User:Polygnotus')
);
}
/**
* @param {string} title
* @return {Promise<string|null>} wikicode
*/
async getWikicode(title) {
try {
const api = new this.mw.Api();
const response = await api.get({
action: 'parse',
page: title,
prop: 'wikitext',
formatversion: '2',
format: 'json'
});
return response.parse.wikitext;
} catch (error) {
console.error('Error fetching wikicode:', error);
return null;
}
}
/**
* Show enhanced dialog with text field for reporting false positives
* @param {string[]} detectedWords
*/
showFalsePositiveDialog(detectedWords) {
// Use MediaWiki's OOjs UI dialog framework
mw.loader.using(['oojs-ui-core', 'oojs-ui-windows', 'oojs-ui-widgets'], () => {
// Create layout for dialog content
const layout = new OO.ui.FieldsetLayout({
label: 'Report False Positive'
});
// Create a more direct text field for entering word combination
const wordCombinationField = new OO.ui.TextInputWidget({
placeholder: 'Enter word combination (e.g., "outstanding warrant")',
title: 'Enter the exact multi-word combination that should not be flagged as promotional'
});
// Display the detected promotional words for reference
const detectedWordsHtml = $('<div>')
.addClass('detected-words-list')
.css({
'margin-bottom': '10px',
'background-color': '#f8f9fa',
'padding': '8px',
'border-radius': '2px',
'border': '1px solid #eaecf0'
})
.append($('<strong>').text('Detected promotional words: '))
.append(document.createTextNode(detectedWords.join(', ')));
// Add fields to layout
layout.addItems([
new OO.ui.FieldLayout(wordCombinationField, {
label: 'Enter a word combination that is NOT promotional',
align: 'top'
})
]);
// Add the detected words info before the layout
layout.$element.prepend(detectedWordsHtml);
// Add instructions
const instructionsLayout = new OO.ui.PanelLayout({
padded: true,
expanded: false
});
instructionsLayout.$element.append(
$('<div>')
.css('margin-bottom', '1em')
.append($('<p>').text('Please provide a multi-word combination that includes one of the promotional words but is NOT promotional.'))
.append($('<p>').html('<strong>The combination must:</strong>'))
.append($('<ul>')
.append($('<li>').text('Include at least 2 words'))
.append($('<li>').text('Include one of the detected promotional words'))
.append($('<li>').text('Form a phrase that is NOT promotional'))
)
.append($('<p>').text('For example:'))
.append($('<ul>')
.append($('<li>').text('"outstanding" can be promotional, but "outstanding warrant" is not'))
.append($('<li>').text('"leading" can be promotional, but "leading to" is not'))
.append($('<li>').text('"award-winning" can be promotional, but "award-winning ceremony" is not'))
)
);
// Define a proper dialog class with a name
function FalsePositiveDialog(config) {
FalsePositiveDialog.super.call(this, config);
}
OO.inheritClass(FalsePositiveDialog, OO.ui.ProcessDialog);
// Define static properties
FalsePositiveDialog.static.name = 'falsePositiveDialog';
FalsePositiveDialog.static.title = 'Report False Positive';
FalsePositiveDialog.static.actions = [
{
action: 'cancel',
label: 'Cancel',
flags: ['safe', 'close']
},
{
action: 'submit',
label: 'Submit Report',
flags: ['primary', 'progressive']
}
];
FalsePositiveDialog.static.size = 'medium';
// Create message dialog
const messageDialog = new FalsePositiveDialog();
// Define dialog process
FalsePositiveDialog.prototype.getActionProcess = function(action) {
const self = this;
if (action === 'submit') {
const wordCombination = wordCombinationField.getValue().trim();
// Check if the word combination has at least 2 words
const wordCount = wordCombination.split(/\s+/).filter(w => w.length > 0).length;
if (wordCount < 2) {
// Show error message for insufficient words
wordCombinationField.setValidityFlag(false);
return new OO.ui.Process(function() {
self.showErrors(new OO.ui.Error(
'Please enter a multi-word combination (at least 2 words). We only want to exclude word combinations that are not promotional in context.',
{ recoverable: true }
));
});
}
// Check if any of the detected promotional words are part of the combination
const containsPromoWord = detectedWords.some(word =>
wordCombination.toLowerCase().includes(word.toLowerCase())
);
if (!containsPromoWord) {
// Show error message for missing any promotional word
wordCombinationField.setValidityFlag(false);
return new OO.ui.Process(function() {
self.showErrors(new OO.ui.Error(
'Your word combination must include one of the detected promotional words.',
{ recoverable: true }
));
});
}
// Find which promotional word is included in the combination
let includedWord = '';
for (const word of detectedWords) {
if (wordCombination.toLowerCase().includes(word.toLowerCase())) {
includedWord = word;
break;
}
}
// All validation passed, proceed with submission
return new OO.ui.Process(function() {
self.close({
action: action,
selectedWord: includedWord,
wordCombination: wordCombination
});
});
}
// Handle cancel and close actions explicitly
if (action === 'cancel' || action === 'close') {
return new OO.ui.Process(function() {
self.close({ action: action });
});
}
// Fallback for other actions
return FalsePositiveDialog.super.prototype.getActionProcess.call(this, action);
};
// Define dialog setup process - this is the proper way to add content
FalsePositiveDialog.prototype.getSetupProcess = function() {
return FalsePositiveDialog.super.prototype.getSetupProcess.call(this).next(function() {
// Add content to the body
this.$body.append(instructionsLayout.$element, layout.$element);
}, this);
};
// This section is now handled in the static properties
// Add dialog to window manager
const windowManager = new OO.ui.WindowManager();
this.$('body').append(windowManager.$element);
windowManager.addWindows([messageDialog]);
// Open dialog
windowManager.openWindow(messageDialog).closed.then(data => {
if (data && data.action === 'submit') {
this.reportFalsePositive(data.selectedWord, data.wordCombination);
}
});
});
}
/**
* Report false positive by redirecting to the talk page with the word combination
* @param {string} selectedWord - The promotional word selected
* @param {string} wordCombination - The non-promotional word combination
*/
reportFalsePositive(selectedWord, wordCombination) {
const currentPage = this.mw.config.get('wgPageName');
// Use exactly the same URL structure as DuplicateReferences
const baseUrl = 'https://en.wikipedia.org/wiki/User_talk:Polygnotus';
const action = 'edit';
const section = 'new';
const preloadtitle = 'Reporting%20%5B%5BUser%3APolygnotus%2FDetectPromo%7CDetectPromo%5D%5D%20false-positive';
// Note the $1 placeholder in the preload parameter - this is key!
const preload = 'User:Polygnotus/$1';
// Format the preloadparams with the word combination
const preloadparams = encodeURIComponent(`[[${currentPage}]] "${selectedWord}" in phrase "${wordCombination}" is not promotional ~~` + `~~`);
// Construct the final URL to match the example format exactly
const reportURL = `${baseUrl}?action=${action}§ion=${section}&preloadtitle=${preloadtitle}&preload=${preload}&preloadparams%5b%5d=${preloadparams}`;
// Redirect to the report page
window.location.href = reportURL;
}
/**
* @param {string} string
* @return {string} escapedString
*/
escapeRegEx(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
}
$(() => {
mw.loader.using(['mediawiki.api', 'oojs-ui-core', 'oojs-ui-windows', 'oojs-ui-widgets']).then(() => {
new DetectPromo(mw, $).execute();
});
});
// </nowiki>
