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

package/src/languageProcessing/languages/pl/config/sentenceLength.js

@@ -0,0 +1,10 @@
+export default {
+	percentages: {
+		slightlyTooMany: 15,
+		farTooMany: 20,
+	},
+	cornerstonePercentages: {
+		slightlyTooMany: 15,
+		farTooMany: 20,
+	},
+};

package/src/languageProcessing/languages/pl/config/stopWords.js

@@ -0,0 +1,36 @@
+/**
+ * Returns a list with stopwords for the Polish passive voice assessment.
+ * @returns {Array} The list with stopwords.
+ */
+export default [
+	"a",
+	"aby",
+	"albo",
+	"albowiem",
+	"ale",
+	"bo",
+	"bowiem",
+	"czy",
+	"gdy",
+	"gdyby",
+	"gdyż",
+	"iż",
+	"jeśli",
+	"jeżeli",
+	"lub",
+	"ponieważ",
+	"zanim",
+	"żeby",
+	"który",
+	"która",
+	"które",
+	"którzy",
+	"którego",
+	"której",
+	"których",
+	"któremu",
+	"którym",
+	"którą",
+	"którymi",
+	"że",
+];

package/src/languageProcessing/languages/pl/config/transitionWords.js

@@ -0,0 +1,42 @@
+/** @module config/transitionWords */
+
+export const singleWords = [ "aby", "abym", "abyśmy", "abyś", "abyście", "acz", "aczkolwiek", "albowiem", "ale", "aliści",
+	"bo", "bowiem", "bynajmniej", "choć", "chociaż", "chociażby", "czyli", "dlatego", "dodatkowo", "dopóki", "dotychczas",
+	"faktycznie", "gdy", "gdyż", "jakkolwiek", "iż", "jednak", "jednakże", "jeśli", "kiedy", "lecz", "mianowicie", "mimo",
+	"np", "najpierw", "następnie", "natomiast", "ni", "niemniej", "niż", "notabene", "oczywiście", "ogółem",
+	"ostatecznie", "owszem", "podobnie", "podsumowując", "pokrótce", "pomimo", "ponadto", "ponieważ", "poprzednio",
+	"potem", "później", "przecież", "przeto", "przynajmniej", "raczej", "również", "rzeczywiście", "skoro", "także",
+	"też", "toteż", "tudzież", "tymczasem", "wedle", "według", "więc", "właściwie", "wobec", "wpierw", "wprawdzie",
+	"wreszcie", "wskutek", "wstępnie", "wszakże", "wszelako", "zamiast", "zanim", "zarówno", "zaś", "zatem", "zresztą",
+	"zwłaszcza", "żeby", "żebym", "żebyś", "żebyście", "żebyśmy" ];
+
+export const multipleWords = [ "a konkretnie", "a propos", "aby wrocić do rzeczy", "analogicznie do", "bacząc na to że",
+	"bądź co bądź", "bez wątpienia", "bez względu", "biorąc pod uwagę", "choćby", "chodzi o to", "chyba że", "co do",
+	"co gorsza", "co prawda", "co się tyczy", "co ważniejsze", "co więcej", "dzięki czemu", "dzięki któremu", "dzięki której",
+	"dzięki którym", "dzięki temu", "faktem jest że", "inaczej mówiąc", "innymi słowy", "jak dotąd", "jak już mówiłam",
+	"jak już mówiłem", "jak już wspomniano", "jak widać", "jak wiemy", "jako przykład", "jednym słowem", "jeśli chodzi o", "jeżeli chodzi o",
+	"konkretnie to", "krótko mówiąc", "łącznie z", "mając to na uwadzę", "mam na myśli", "mamy na myśli",
+	"mówiąc w skrócie", "na celu", "na dłuższą metę", "na dodatek", "na koniec", "na końcu", "na przykład", "na skutek",
+	"na wstęp", "na wypadek gdyby", "na zakończenie", "nade wszystko", "należy pamiętać", "nawiasem mówiąc",
+	"nie mówiąc już", "nie mówiąc o tym", "nie pomijając", "nie schodząc z tematu", "nie wspominając już",
+	"nie wspominając o", "nie wspominając to", "nie wspominając że", "nie zważając na", "o ile", "o tyle",
+	"od czasu do czasu", "od momentu", "odnośnie do", "ogólnie mówiąc", "ogólnie rzecz biorąc", "oprócz tego",
+	"oznacza to że", "po czwarte", "po drugie", "po piąte", "po pierwsze", "po to", "po trzecie", "pod warunkiem",
+	"podczas gdy", "podczas kiedy", "podobnym sposobem", "ponad wszystko", "poza tym", "prawdę mówiąc",
+	"prawdę powiedziawszy", "prędzej czy później", "przechodząc do", "przede wszystkim", "przez co", "przez tą",
+	"przez tego", "przez to", "przy tym", "przypuściwszy że", "raz na jakiś czas", "rzecz jasna", "ściśle biorąc",
+	"ściśle mówiąc", "skutkiem tego", "tak czy inaczej", "tak czy owak", "tak naprawdę", "takich jak", "takie jak",
+	"to znaczy", "tym samym", "w celu", "w ciągu", "w dodatku", "w efekcie", "w innych słowach", "w istocie", "w każdym razie",
+	"w końcu", "w konsekwencji", "w kwestii", "w międzyczasie", "w nadziei że", "w obawie że", "w odróżnieniu",
+	"w podobny sposób", "w podsumowaniu", "w przeciwieństwie do", "w przeciwnym razie", "w przypadku", "w rezultacie",
+	"w rozumieniu że", "w rzeczy samej", "w rzeczywistości", "w skrócie", "w szczególności", "w takim razie",
+	"w ten sposób", "w tych okolicznościach", "w tym przypadku", "w wyniku", "w wyniku tego", "w związku z tym",
+	"wbrew pozorom", "włącznie z", "wracając do rzeczy", "wracając do tematu", "wręcz przeciwnie", "z drugiej strony",
+	"z drugiej zaś strony", "z jednej strony", "z mocy że", "z obawy że", "z pewnością", "z powodu", "z przyczyny",
+	"z tą intencją", "z tego powodu", "z uwagi że", "zacznijmy od", "zakładając że", "ze względu na", "ze względu że",
+	"zważywszy na to", "zważywszy że" ];
+
+export const allWords = singleWords.concat( multipleWords );
+
+export default allWords;
+

package/src/languageProcessing/languages/pl/config/twoPartTransitionWords.js

@@ -0,0 +1,8 @@
+/** @module config/twoPartTransitionWords */
+
+/**
+ * Returns an array with two-part transition words to be used by the assessments.
+ * @type {Array} The array filled with two-part transition words.
+ */
+export default [ [ "albo", "albo" ], [ "ani", "ani" ], [ "czy", "czy" ], [ "im", "tym" ], [ "tak", "jak" ] ];
+

package/src/languageProcessing/languages/pl/helpers/getClauses.js

@@ -0,0 +1,25 @@
+import {languageProcessing} from '../../../index';
+const {getClausesSplitOnStopWords, createRegexFromArray} = languageProcessing;
+
+import Clause from '../values/Clause';
+import auxiliaries from '../config/internal/auxiliaries.js';
+import stopwords from '../config/stopWords.js';
+
+const options = {
+  Clause,
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries),
+    stopwordRegex: createRegexFromArray(stopwords)
+  }
+};
+
+/**
+ * Gets the sentence parts from a sentence by determining sentence breakers.
+ *
+ * @param {string} sentence The sentence to split up in sentence parts.
+ *
+ * @returns {Array} The array with all parts of a sentence that have an auxiliary.
+ */
+export default function getClauses(sentence) {
+  return getClausesSplitOnStopWords(sentence, options);
+}

package/src/languageProcessing/languages/pl/helpers/getStemmer.js

@@ -0,0 +1,22 @@
+import {get} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {baseStemmer} = languageProcessing;
+
+import stem from './internal/stem';
+
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+export default function getStemmer(researcher) {
+  const morphologyData = get(researcher.getData('morphology'), 'pl', false);
+
+  if (morphologyData) {
+    return word => stem(word, morphologyData);
+  }
+
+  return baseStemmer;
+}

package/src/languageProcessing/languages/pl/helpers/internal/getParticiples.js

@@ -0,0 +1,18 @@
+import {includes} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+import participles from '../../config/internal/participles';
+
+/**
+ * Creates an array of participles for the participles found in a clause.
+ *
+ * @param {string} clauseText The sentence part to find participles in.
+ *
+ * @returns {Array} The list with participles.
+ */
+export default function getParticiples(clauseText) {
+  const words = getWords(clauseText);
+
+  return words.filter(word => includes(participles, word));
+}

package/src/languageProcessing/languages/pl/helpers/internal/stem.js

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2017 Błażej Kubiński
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * Loops through an array of word endings and returns ending that was matched at the end of the word.
+ *
+ * @param {string}      word       The word to check.
+ * @param {string[]}    endings    The word endings to check.
+ * @returns {string}    The matched ending.
+ */
+const endsInArr = function( word, endings ) {
+	const match = endings.find( ending => word.endsWith( ending ) );
+	return match ? match : "";
+};
+
+/**
+ * Checks if a word is longer than the word length threshold specified for a given suffix group. If the word length does not
+ * meet the threshold, it is not stemmed.
+ *
+ * If it does meet the threshold, checks whether the word ends with one of the endings from the inputted array. If it does,
+ * it removes the suffix from the end of the word.
+ *
+ * The length of the actual suffix is not always equal to the length of the checked ending, so suffix length is a separate
+ * parameter. For example, the word 'rowerek' ends with -erek, one of the endings from the diminutive group. However, for
+ * that ending, the suffix length is defined as 2 so only -ek is stemmed.
+ *
+ * @param {string} word            The word to stem.
+ * @param {number} wordLength      The length of the word.
+ * @param {string[]} wordEndings   The suffix group.
+ * @param {number} suffixLength    The length of the suffix.
+ *
+ * @returns {string}               The stemmed word.
+ */
+const findSuffixInGroupAndStem = function( word, wordLength, wordEndings, suffixLength ) {
+	if ( word.length > wordLength ) {
+		const longestMatchedWordEnding = endsInArr( word, wordEndings );
+
+		if ( longestMatchedWordEnding !== "" ) {
+			return word.slice( 0, -suffixLength );
+		}
+	}
+};
+
+/**
+ * Goes through all the suffix groups in a given class (i.e., diminutive, noun, verb, adjective/adverb or general) and
+ * stems the word if a suffix is found and should be stemmed.
+ *
+ * @param {string}      word            The word to stem.
+ * @param {Object}      suffixClass     The class of suffixes to check.
+ * @returns {string}    The stemmed word.
+ */
+const findSuffixInClassAndStem = function( word, suffixClass ) {
+	const suffixClassArray = Object.entries( suffixClass );
+	for ( const suffixGroup of suffixClassArray ) {
+		const wordShouldBeLongerThan = suffixGroup[ 1 ].wordShouldBeLongerThan;
+		const wordEndings = suffixGroup[ 1 ].wordEndings;
+		const suffixLength = suffixGroup[ 1 ].suffixLength;
+
+		const stemmedWord = findSuffixInGroupAndStem( word, wordShouldBeLongerThan, wordEndings, suffixLength );
+
+		if ( stemmedWord ) {
+			return stemmedWord;
+		}
+	}
+};
+
+/**
+ * Stems adjective and adverb suffixes. After stemming the suffixes, looks for the superlative prefix 'naj' and stems it
+ * as well if found. For example, in 'najsilniejsze', first the 'ejsze' is stemmed and then the 'naj'.
+ *
+ * @param {string}  word                	The word to stem.
+ * @param {Object}  ruleBasedStemmerData    The data for the rule-based stemmer.
+ *
+ * @returns {string} The word with removed adjective/adverb suffixes
+ */
+const stemAdjectivesAndAdverbs = function( word, ruleBasedStemmerData ) {
+	const stemmedWord = findSuffixInClassAndStem( word, ruleBasedStemmerData.adjectiveAndAdverbSuffixes );
+
+	if ( stemmedWord ) {
+		// Remove superlative prefix if found
+		if ( word.startsWith( ruleBasedStemmerData.superlativePrefix ) ) {
+			return stemmedWord.slice( 3 );
+		}
+		return stemmedWord;
+	}
+};
+
+/**
+ * Stems Polish words.
+ *
+ * @param {string}  word                The word to stem.
+ * @param {Object}  morphologyData      The Polish morphology data file.
+ *
+ * @returns {string} The stemmed word.
+ */
+export default function stem( word, morphologyData ) {
+	const ruleBasedStemmerData = morphologyData.externalStemmer;
+	const dictionaryStemmer = morphologyData.dictionary.stems;
+
+	// Check if the word exists in the dictionary stemmer. If yes, replace the word with the base form of the word specified in the dictionary.
+	let stemmedWord = dictionaryStemmer[ word ];
+	if ( stemmedWord ) {
+		word = stemmedWord;
+	}
+
+	word.toLowerCase();
+
+	// If the word is three characters long or shorter, the stem should be the same as the word.
+	if ( word.length < 4 ) {
+		return word;
+	}
+
+	/*
+	 * Go through diminutive, noun, verb, and adjective stemming steps. If a suffix (and optional prefix in case of adjectives/adverbs)
+	 *  is found, delete it and stop searching further.
+	 */
+	stemmedWord = findSuffixInClassAndStem( word, ruleBasedStemmerData.diminutiveSuffixes );
+
+	if ( ! stemmedWord ) {
+		stemmedWord = findSuffixInClassAndStem( word, ruleBasedStemmerData.nounSuffixes );
+	}
+
+	if ( ! stemmedWord ) {
+		stemmedWord = findSuffixInClassAndStem( word, ruleBasedStemmerData.verbSuffixes );
+	}
+
+	if ( ! stemmedWord ) {
+		stemmedWord = stemAdjectivesAndAdverbs( word, ruleBasedStemmerData );
+	}
+
+	// If the word was stemmed in any of the previous steps, replace the word with the stem.
+	if ( stemmedWord ) {
+		word = stemmedWord;
+	}
+
+	// Find and stem general suffixes
+	stemmedWord = findSuffixInClassAndStem( word, ruleBasedStemmerData.generalSuffixes );
+
+	if ( stemmedWord ) {
+		return stemmedWord;
+	}
+
+	return word;
+}

package/src/languageProcessing/languages/pl/values/Clause.js

@@ -0,0 +1,53 @@
+import getParticiples from '../helpers/internal/getParticiples.js';
+import {languageProcessing} from '../../../index';
+const {nonDirectPrecedenceException, directPrecedenceException, values} = languageProcessing;
+const {Clause} = values;
+import {
+  cannotBeBetweenPassiveAuxiliaryAndParticiple,
+  cannotDirectlyPrecedePassiveParticiple
+} from '../config/functionWords';
+
+/**
+ * Creates a Clause object for the Polish language.
+ */
+class PolishClause extends Clause {
+  /**
+   * Constructor.
+   *
+   * @param {string} clauseText   The text of the clause.
+   * @param {Array} auxiliaries   The auxiliaries.
+   *
+   * @constructor
+   */
+  constructor(clauseText, auxiliaries) {
+    super(clauseText, auxiliaries);
+    this._participles = getParticiples(this.getClauseText());
+    this.checkParticiples();
+  }
+
+  /**
+   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.
+   * If no exceptions are found, the clause is passive.
+   *
+   * @returns {boolean} Returns true if no exception is found.
+   */
+  checkParticiples() {
+    const clause = this.getClauseText();
+    const auxiliaries = this.getAuxiliaries();
+
+    const passiveParticiples = this.getParticiples().filter(
+      participle =>
+        !directPrecedenceException(clause, participle, cannotDirectlyPrecedePassiveParticiple) &&
+        !nonDirectPrecedenceException(
+          clause,
+          participle,
+          auxiliaries,
+          cannotBeBetweenPassiveAuxiliaryAndParticiple
+        )
+    );
+
+    this.setPassive(passiveParticiples.length > 0);
+  }
+}
+
+export default PolishClause;

package/src/languageProcessing/languages/pt/Researcher.js

@@ -0,0 +1,48 @@
+import {languageProcessing} from '../../../index';
+const {AbstractResearcher} = languageProcessing;
+
+// All config
+import firstWordExceptions from './config/firstWordExceptions';
+import {all as functionWords} from './config/functionWords';
+import stopWords from './config/stopWords';
+import transitionWords from './config/transitionWords';
+import twoPartTransitionWords from './config/twoPartTransitionWords';
+import syllables from './config/syllables.json';
+import sentenceLength from './config/sentenceLength';
+
+// All helpers
+import getClauses from './helpers/getClauses';
+import getStemmer from './helpers/getStemmer';
+import fleschReadingScore from './helpers/calculateFleschReadingScore';
+
+/**
+ * The researcher contains all the researches, helpers, data, and config.
+ */
+export default class Researcher extends AbstractResearcher {
+  /**
+   * Constructor
+   * @param {Paper} paper The Paper object that is needed within the researches.
+   * @constructor
+   */
+  constructor(paper) {
+    super(paper);
+
+    Object.assign(this.config, {
+      language: 'pt',
+      passiveConstructionType: 'periphrastic',
+      firstWordExceptions,
+      functionWords,
+      stopWords,
+      transitionWords,
+      twoPartTransitionWords,
+      syllables,
+      sentenceLength
+    });
+
+    Object.assign(this.helpers, {
+      getClauses,
+      getStemmer,
+      fleschReadingScore
+    });
+  }
+}

package/src/languageProcessing/languages/pt/config/firstWordExceptions.js

@@ -0,0 +1,15 @@
+/**
+ * Returns an array with exceptions for the sentence beginning researcher.
+ * @returns {Array} The array filled with exceptions.
+ */
+export default [
+	// Definite articles:
+	"o", "a", "os", "as",
+	// Indefinite articles:
+	"um", "uma", "uns", "umas",
+	// Numbers 1-10:
+	"um", "dois", "três", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez",
+	// Demonstrative pronouns:
+	"este", "estes", "esta", "estas", "esse", "esses", "essa", "essas", "aquele",
+	"aqueles", "aquela", "aquelas", "isto", "isso", "aquilo" ];
+