axyseo 2.0.0-alpha.0.0.19 → 2.0.0-alpha.0.0.2

package/src/scoring/helpers/index.js

@@ -0,0 +1,74 @@
+import {
+  contentSEOCategory,
+  POINT,
+  priorityRate,
+  technicalSEOCategory
+} from '../../../const/analysis';
+
+/**
+ * Helper function to prepare the results by category.
+ * @param {Array} originalResult - The original result array of assessments.
+ * @returns {object} The prepared result object.
+ */
+export function groupAssessmentsByCategory(originalResult) {
+  const technicalSEOResults = [];
+  const contentSEOResults = [];
+
+  originalResult.forEach(item => {
+    const {id, status} = item;
+
+    if (technicalSEOCategory.includes(id)) {
+      technicalSEOResults.push({...item, status});
+    } else if (contentSEOCategory.includes(id)) {
+      contentSEOResults.push({...item, status});
+    }
+  });
+
+  const sortByStatus = (a, b) => {
+    const statusOrder = {bad: 1, improve: 2, good: 3};
+    return statusOrder[a.status] - statusOrder[b.status];
+  };
+
+  const sortByPriority = (a, b) => {
+    const priorityOrder = {high: 1, medium: 2, low: 3, undefined: 4};
+    return (priorityOrder[a.priority] || 4) - (priorityOrder[b.priority] || 4);
+  };
+
+  const sortItems = items => {
+    items.sort((a, b) => {
+      const statusComparison = sortByStatus(a, b);
+      if (statusComparison !== 0) {
+        return statusComparison;
+      }
+      return sortByPriority(a, b);
+    });
+  };
+
+  sortItems(technicalSEOResults);
+  sortItems(contentSEOResults);
+
+  return {technicalSEOResults, contentSEOResults};
+}
+
+export function groupAssessmentsByStatus(assessments) {
+  return assessments.reduce(
+    (acc, assessment) => {
+      const {status} = assessment;
+      if (!acc[status]) {
+        acc[status] = [];
+      }
+      acc[status].push(assessment);
+      return acc;
+    },
+    {good: [], improve: [], bad: []}
+  );
+}
+
+export const getMaxPoint = assessments => {
+  let totalScore = 0;
+  assessments.forEach(item => {
+    totalScore += POINT * priorityRate[item.priority];
+  });
+
+  return totalScore;
+};

package/src/scoring/interpreters/index.js

@@ -0,0 +1,5 @@
+import scoreToRating from "./scoreToRating";
+
+export {
+	scoreToRating,
+};

package/src/scoring/interpreters/scoreToRating.js

@@ -0,0 +1,31 @@
+/**
+ * Interpreters a score and gives it a particular rating.
+ *
+ * @param {Number} score The score to interpreter.
+ * @returns {string} The rating, given based on the score.
+ */
+const ScoreToRating = function( score ) {
+	if ( score === -1 ) {
+		return "error";
+	}
+
+	if ( score === 0 ) {
+		return "feedback";
+	}
+
+	if ( score <= 4 ) {
+		return "bad";
+	}
+
+	if ( score > 4 && score <= 7 ) {
+		return "ok";
+	}
+
+	if ( score > 7 ) {
+		return "good";
+	}
+
+	return "";
+};
+
+export default ScoreToRating;

package/src/scoring/renderers/AssessorPresenter.js

@@ -0,0 +1,360 @@
+import { difference, forEach, isNumber, isObject, isUndefined } from "lodash";
+import scoreToRating from "../interpreters/scoreToRating.js";
+import createConfig from "../../config/presenter.js";
+
+/**
+ * Represents the AssessorPresenter.
+ */
+class AssessorPresenter {
+	/**
+	 * Constructs the AssessorPresenter.
+	 *
+	 * @param {Object} args A list of arguments to use in the presenter.
+	 * @param {object} args.targets The HTML elements to render the output to.
+	 * @param {string} args.targets.output The HTML element to render the individual ratings out to.
+	 * @param {string} args.targets.overall The HTML element to render the overall rating out to.
+	 * @param {string} args.keyword The keyword to use for checking, when calculating the overall rating.
+	 * @param {SEOAssessor} args.assessor The Assessor object to retrieve assessment results from.
+	 *
+	 * @constructor
+	 */
+	constructor(  args ) {
+		this.keyword = args.keyword;
+		this.assessor = args.assessor;
+		this.output = args.targets.output;
+		this.overall = args.targets.overall || "overallScore";
+		this.presenterConfig = createConfig();
+
+		this._disableMarkerButtons = false;
+
+		this._activeMarker = false;
+	}
+
+	/**
+	 * Sets the keyword.
+	 *
+	 * @param {string} keyword The keyword to use.
+	 * @returns {void}
+	 */
+	setKeyword( keyword ) {
+		this.keyword = keyword;
+	}
+
+	/**
+	 * Checks whether a specific property exists in the presenter configuration.
+	 *
+	 * @param {string} property The property name to search for.
+	 * @returns {boolean} Whether or not the property exists.
+	 */
+	configHasProperty( property ) {
+		return this.presenterConfig.hasOwnProperty( property );
+	}
+
+	/**
+	 * Gets a fully formatted indicator object that can be used.
+	 *
+	 * @param {string} rating The rating to use.
+	 * @returns {Object} An object containing the class, the screen reader text, and the full text.
+	 */
+	getIndicator( rating ) {
+		return {
+			className: this.getIndicatorColorClass( rating ),
+			screenReaderText: this.getIndicatorScreenReaderText( rating ),
+			fullText: this.getIndicatorFullText( rating ),
+			screenReaderReadabilityText: this.getIndicatorScreenReaderReadabilityText( rating ),
+		};
+	}
+
+	/**
+	 * Gets the indicator color class from the presenter configuration, if it exists.
+	 *
+	 * @param {string} rating The rating to check against the config.
+	 * @returns {string} String containing the CSS class to be used.
+	 */
+	getIndicatorColorClass( rating ) {
+		if ( ! this.configHasProperty( rating ) ) {
+			return "";
+		}
+
+		return this.presenterConfig[ rating ].className;
+	}
+
+	/**
+	 * Gets the indicator screen reader text from the presenter configuration, if it exists.
+	 *
+	 * @param {string} rating The rating to check against the config.
+	 * @returns {string} Translated string containing the screen reader text to be used.
+	 */
+	getIndicatorScreenReaderText( rating ) {
+		if ( ! this.configHasProperty( rating ) ) {
+			return "";
+		}
+
+		return this.presenterConfig[ rating ].screenReaderText;
+	}
+
+	/**
+	 * Gets the indicator screen reader readability text from the presenter configuration, if it exists.
+	 *
+	 * @param {string} rating The rating to check against the config.
+	 * @returns {string} Translated string containing the screen reader readability text to be used.
+	 */
+	getIndicatorScreenReaderReadabilityText( rating ) {
+		if ( ! this.configHasProperty( rating ) ) {
+			return "";
+		}
+
+		return this.presenterConfig[ rating ].screenReaderReadabilityText;
+	}
+
+	/**
+	 * Gets the indicator full text from the presenter configuration, if it exists.
+	 *
+	 * @param {string} rating The rating to check against the config.
+	 * @returns {string} Translated string containing the full text to be used.
+	 */
+	getIndicatorFullText( rating ) {
+		if ( ! this.configHasProperty( rating ) ) {
+			return "";
+		}
+
+		return this.presenterConfig[ rating ].fullText;
+	}
+
+	/**
+	 * Adds a rating based on the numeric score.
+	 *
+	 * @param {Object} result Object based on the Assessment result. Requires a score property to work.
+	 * @returns {Object} The Assessment result object with the rating added.
+	 */
+	resultToRating( result ) {
+		if ( ! isObject( result ) ) {
+			return "";
+		}
+
+		result.rating = scoreToRating( result.score );
+
+		return result;
+	}
+
+	/**
+	 * Takes the individual assessment results, sorts and rates them.
+	 *
+	 * @returns {Object} Object containing all the individual ratings.
+	 */
+	getIndividualRatings() {
+		const ratings = {};
+		const validResults = this.sort( this.assessor.getValidResults() );
+		const mappedResults = validResults.map( this.resultToRating );
+
+		forEach( mappedResults, function( item, key ) {
+			ratings[ key ] = this.addRating( item );
+		}.bind( this ) );
+
+		return ratings;
+	}
+
+	/**
+	 * Excludes items from the results that are present in the `exclude` array.
+	 *
+	 * @param {Array} results Array containing the items to filter through.
+	 * @param {Array} exclude Array of results to exclude.
+	 * @returns {Array} Array containing items that remain after exclusion.
+	 */
+	excludeFromResults( results, exclude ) {
+		return difference( results, exclude );
+	}
+
+	/**
+	 * Sorts results based on their score property and always places items considered to be non-sortable, at the top.
+	 *
+	 * @param {Array} results Array containing the results that need to be sorted.
+	 * @returns {Array} Array containing the sorted results.
+	 */
+	sort( results ) {
+		const nonSortables = this.getUndefinedScores( results );
+		const sortables = this.excludeFromResults( results, nonSortables );
+
+		sortables.sort( function( a, b ) {
+			return a.score - b.score;
+		} );
+
+		return nonSortables.concat( sortables );
+	}
+
+	/**
+	 * Returns a subset of results that have an undefined score or a score set to zero.
+	 *
+	 * @param {Array} results The results to filter through.
+	 * @returns {Array} A subset of results containing items with an undefined score or where the score is zero.
+	 */
+	getUndefinedScores( results ) {
+		return results.filter( function( result ) {
+			return isUndefined( result.score ) || result.score === 0;
+		} );
+	}
+
+	/**
+	 * Creates a rating object based on the item that is being passed.
+	 *
+	 * @param {Object} item The item to check and create a rating object from.
+	 * @returns {Object} Object containing a parsed item, including a colored indicator.
+	 */
+	addRating( item ) {
+		const indicator = this.getIndicator( item.rating );
+		indicator.text = item.text;
+		indicator.identifier = item.getIdentifier();
+
+		if ( item.hasMarker() ) {
+			indicator.marker = item.getMarker();
+		}
+
+		return indicator;
+	}
+
+	/**
+	 * Calculates the overall rating score based on the overall score.
+	 *
+	 * @param {Number} overallScore The overall score to use in the calculation.
+	 * @returns {Object} The rating based on the score.
+	 */
+	getOverallRating( overallScore ) {
+		let rating = 0;
+
+		if ( this.keyword === "" ) {
+			return this.resultToRating( { score: rating } );
+		}
+
+		if ( isNumber( overallScore ) ) {
+			rating = ( overallScore / 10 );
+		}
+
+		return this.resultToRating( { score: rating } );
+	}
+
+	/**
+	 * Marks with a given marker. This will set the active marker to the correct value.
+	 *
+	 * @param {string} identifier The identifier for the assessment/marker.
+	 * @param {Function} marker The marker function.
+	 * @returns {void}
+	 */
+	markAssessment( identifier, marker ) {
+		if ( this._activeMarker === identifier ) {
+			this.removeAllMarks();
+			this._activeMarker = false;
+		} else {
+			marker();
+			this._activeMarker = identifier;
+		}
+
+		this.render();
+	}
+
+	/**
+	 * Disables the currently active marker in the UI.
+	 *
+	 * @returns {void}
+	 */
+	disableMarker() {
+		this._activeMarker = false;
+		this.render();
+	}
+
+	/**
+	 * Disables the marker buttons.
+	 *
+	 * @returns {void}
+	 */
+	disableMarkerButtons() {
+		this._disableMarkerButtons = true;
+		this.render();
+	}
+
+	/**
+	 * Enables the marker buttons.
+	 *
+	 * @returns {void}
+	 */
+	enableMarkerButtons() {
+		this._disableMarkerButtons = false;
+		this.render();
+	}
+
+	/**
+	 * Adds an event listener for the marker button
+	 *
+	 * @param {string} identifier The identifier for the assessment the marker belongs to.
+	 * @param {Function} marker The marker function that can mark the assessment in the text.
+	 * @returns {void}
+	 */
+	addMarkerEventHandler( identifier, marker ) {
+		const container = document.getElementById( this.output );
+		const markButton = container.getElementsByClassName( "js-assessment-results__mark-" + identifier )[ 0 ];
+
+		markButton.addEventListener( "click", this.markAssessment.bind( this, identifier, marker ) );
+	}
+
+	/**
+	 * Renders out both the individual and the overall ratings.
+	 *
+	 * @returns {void}
+	 */
+	render() {
+		this.renderIndividualRatings();
+		this.renderOverallRating();
+	}
+
+	/**
+	 * Adds event handlers to the mark buttons.
+	 *
+	 * @param {Object} scores The list of rendered scores.
+	 *
+	 * @returns {void}
+	 */
+	bindMarkButtons( scores ) {
+		// Make sure the button works for every score with a marker.
+		forEach( scores, function( score ) {
+			if ( score.hasOwnProperty( "marker" ) ) {
+				this.addMarkerEventHandler( score.identifier, score.marker );
+			}
+		}.bind( this ) );
+	}
+
+	/**
+	 * Removes all marks currently on the text.
+	 *
+	 * @returns {void}
+	 */
+	removeAllMarks() {
+		const marker = this.assessor.getSpecificMarker();
+
+		marker( this.assessor.getPaper(), [] );
+	}
+
+	/**
+	 * Renders out the individual ratings.
+	 * Here, this method is set to noop. In `post-scraper.js` and `term-scraper.js` where this method is called, it is overridden with noop as well.
+	 *
+	 * @returns {void}
+	 */
+	renderIndividualRatings() {}
+
+	/**
+	 * Renders out the overall rating.
+	 *
+	 * @returns {void}
+	 */
+	renderOverallRating() {
+		const overallRating = this.getOverallRating( this.assessor.calculateOverallScore() );
+		const overallRatingElement = document.getElementById( this.overall );
+
+		if ( ! overallRatingElement ) {
+			return;
+		}
+
+		overallRatingElement.className = "overallScore " + this.getIndicatorColorClass( overallRating.rating );
+	}
+}
+
+export default AssessorPresenter;

package/src/scoring/scoreAggregators/ReadabilityScoreAggregator.js

@@ -0,0 +1,203 @@
+import getLanguage from "../../languageProcessing/helpers/language/getLanguage";
+import { scoreToRating } from "../interpreters";
+
+/* Internal dependencies */
+import ScoreAggregator from "./ScoreAggregator";
+
+/**
+ * Penalties that can be given on each assessment
+ * when all assessments are currently supported
+ * for the user's language.
+ *
+ * @type {{ok: number, bad: number, good: number}}
+ * @const
+ *
+ * @memberOf module:parsedPaper/assess
+ */
+const PENALTY_MAPPING_FULL_SUPPORT = {
+	bad: 3,
+	ok: 2,
+	good: 0,
+};
+
+/**
+ * Penalties that can be given on each assessment
+ * when only a part of the assessments are currently supported
+ * for the user's language.
+ *
+ * @type {{ok: number, bad: number, good: number}}
+ * @const
+ *
+ * @memberOf module:parsedPaper/assess
+ */
+const PENALTY_MAPPING_PARTIAL_SUPPORT = {
+	bad: 4,
+	ok: 2,
+	good: 0,
+};
+
+/**
+ * The scores that can be given on the readability analysis.
+ *
+ * @type {{GOOD: number, OKAY: number, NEEDS_IMPROVEMENT: number, NOT_AVAILABLE: number}}
+ * @const
+ *
+ * @memberOf module:parsedPaper/assess
+ */
+export const READABILITY_SCORES = {
+	GOOD: 90,
+	OKAY: 60,
+	NEEDS_IMPROVEMENT: 30,
+	NOT_AVAILABLE: 0,
+};
+
+/**
+ * A list of all the languages that have full support in the readability analysis.
+ *
+ * @type {string[]}
+ * @const
+ */
+const FULLY_SUPPORTED_LANGUAGES = [ "en", "nl", "de", "it", "ru", "fr", "es" ];
+
+/**
+ * Aggregates the results of the readability analysis into a single score.
+ *
+ * @memberOf module:parsedPaper/assess
+ */
+class ReadabilityScoreAggregator extends ScoreAggregator {
+	/**
+	 * Determines whether a language is fully supported.
+	 *
+	 * @param {string} locale The locale for which the content is written, e.g. `sv-SE` for Sweden.
+	 *
+	 * @returns {boolean} `true` if fully supported.
+	 */
+	isFullySupported( locale ) {
+		// Sanity check if this is actually a locale string.
+		if ( locale && locale.includes( "_" ) ) {
+			const language = getLanguage( locale );
+			return FULLY_SUPPORTED_LANGUAGES.includes( language );
+		}
+		// Default to not fully supported.
+		return false;
+	}
+
+	/**
+	 * Calculates the overall score (GOOD, OKAY or NEEDS IMPROVEMENT)
+	 * based on the penalty.
+	 *
+	 * @param {boolean} isFullySupported Whether this language is fully supported.
+	 * @param {number}  penalty          The total penalty.
+	 *
+	 * @returns {number} The overall score.
+	 */
+	calculateScore( isFullySupported, penalty ) {
+		if ( isFullySupported ) {
+			/*
+			 * If the language is fully supported, we are more lenient.
+			 * A higher penalty is needed to get lower scores.
+			 */
+			if ( penalty > 6 ) {
+				return READABILITY_SCORES.NEEDS_IMPROVEMENT;
+			}
+
+			if ( penalty > 4 ) {
+				/*
+				 * A penalty between 4 and 6 means either:
+				 *  - One "ok" and one "bad" result (5).
+				 *  - Two "bad" results of 3 points each (6).
+				 *  - Three "ok" results of 2 points each (6).
+				 */
+				return READABILITY_SCORES.OKAY;
+			}
+		} else {
+			/*
+			 * If the language is NOT fully supported, we are more stringent.
+			 * The penalty threshold for getting lower scores is set lower.
+			 */
+			if ( penalty > 4 ) {
+				return READABILITY_SCORES.NEEDS_IMPROVEMENT;
+			}
+
+			if ( penalty > 2 ) {
+				/*
+				 * A penalty of 3 or 4 means:
+				 *  - Two "ok" results of 2 points each (4).
+				 *  - One "bad" result of 4 points (4).
+				 */
+				return READABILITY_SCORES.OKAY;
+			}
+		}
+		return READABILITY_SCORES.GOOD;
+	}
+
+	/**
+	 * Calculates the total penalty based on the given assessment results.
+	 *
+	 * @param {AssessmentResult[]} results The valid results from which to calculate the total penalty.
+	 *
+	 * @returns {number} The total penalty for the results.
+	 */
+	calculatePenalty( results ) {
+		return results.reduce( ( sum, result ) => {
+			// Compute the rating ("error", "feedback", "bad", "ok" or "good").
+			const rating = scoreToRating( result.getScore() );
+
+			const penalty = this.isFullySupported( this.locale )
+				? PENALTY_MAPPING_FULL_SUPPORT[ rating ]
+				: PENALTY_MAPPING_PARTIAL_SUPPORT[ rating ];
+
+			// Add penalty when available.
+			return penalty ? sum + penalty : sum;
+		}, 0 );
+	}
+
+	/**
+	 * Returns the list of valid results.
+	 * Valid results are all results that have a score and a text.
+	 *
+	 * @param {AssessmentResult[]} results The results to filter the valid results from.
+	 *
+	 * @returns {AssessmentResult[]} The list of valid results.
+	 */
+	getValidResults( results ) {
+		return results.filter( result => result.hasScore() && result.hasText() );
+	}
+
+	/**
+	 * Sets the locale of the content. We are more lenient on languages
+	 * that are fully supported in the analysis.
+	 *
+	 * @param {string} locale The locale of the content.
+	 *
+	 * @returns {void}
+	 */
+	setLocale( locale ) {
+		this.locale = locale;
+	}
+
+	/**
+	 * Aggregates the given assessment results into a single analysis score.
+	 *
+	 * @param {AssessmentResult[]} results The assessment results.
+	 *
+	 * @returns {number} The aggregated score.
+	 */
+	aggregate( results ) {
+		const validResults = this.getValidResults( results );
+
+		/*
+		 * If you have no content, you have a gray indicator.
+		 * (Assume that one result always means the 'no content' assessment result).
+		 */
+		if ( validResults.length <= 1 ) {
+			return READABILITY_SCORES.NOT_AVAILABLE;
+		}
+
+		const penalty = this.calculatePenalty( validResults );
+		const isFullySupported = this.isFullySupported( this.locale );
+		return this.calculateScore( isFullySupported, penalty );
+	}
+}
+
+export default ReadabilityScoreAggregator;