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

package/src/languageProcessing/languages/sk/config/internal/passiveVoiceAuxiliaries.js

@@ -0,0 +1,22 @@
+// These auxiliaries are filtered from the beginning of word combinations in the prominent words.
+export const filteredAuxiliaries =  [
+	"byť",
+	"som",
+	"si",
+	"je",
+	"sme",
+	"ste",
+	"sú",
+	"bol",
+	"bola",
+	"boli",
+	"bolo",
+	"budem",
+	"budeš",
+	"bude",
+	"budeme",
+	"budete",
+	"budú",
+];
+
+export default filteredAuxiliaries;

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

@@ -0,0 +1,34 @@
+/**
+ * Returns a list with stopwords for the Slovak passive voice assessment.
+ *
+ * @returns {Array}                 The list with stopwords.
+ */
+export default [
+	"ktorí",
+	"ktorých",
+	"ktorými",
+	"ktorá",
+	"ktorého",
+	"ktorému",
+	"ktorom",
+	"ktorým",
+	"ktorý",
+	"ktoré",
+	"ktorej",
+	"ktorou",
+	"ktorú",
+	"lebo",
+	"keby",
+	"že",
+	"aby",
+	"alebo",
+	"keďže",
+	"kedže",
+	"lenže",
+	"ale",
+	"nakoľko",
+	"pretože",
+	"či",
+	"ak",
+	"kedy",
+];

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

@@ -0,0 +1,23 @@
+/** @module config/transitionWords */
+
+export const singleWords = [ "kvôli", "miesto", "pre", "oproti", "aj", "i", "ani", "ale", "avšak", "však", "preto", "tak", "teda",
+	"hoci", "aby", "ako", "keď", "keďže", "kým", "pokiaľ", "ohľadne", "takto", "tiež ", "potom", "takže", "odtiaľ", "odteraz",
+	"lebo", "akonáhle", "lenže", "okrem", "nakoľko", "pokým", "pretože", "čiže", "jednako", "doteraz", "dosiaľ", "najmä",
+	"napríklad", "napr.", "napokon", "predsa", "určite", "dodatočne", "ďalej", "následne", "napriek", "hlavne", "nakoniec",
+	"medzitým", "inak ", "ináč", "obdobne", "podobne", "predovšetkým", "naozaj", "spočiatku ", "najprv", "najskôr", "stručne",
+	"všeobecne", "samozrejme", "pravdaže", "doposiaľ", "nielen", "než", "síce", "pričom", "až", "jednak", "zato", "nielenže",
+	"ibaže", "skôr", "prv", "hoc", "namiesto", "buďto", "inakšie", "hneď", "kedykoľvek" ];
+
+export const multipleWords = [ "ako aj", "ako i", "a tak ďalej", "a tak", "aj tak", "a jednako", "a naopak", "a predsa", "ale jednako",
+	"ale predsa", "a tým", "a to", "i to", "jednako však", "predsa však", "to jest", "a preto", "i keby", "i keď", "čo aj",
+	"keby aj", "pretor, aby", "odvtedy čo", "zatiar čo", "vzhľadom na to, že", "berúc do úvahy, že", "napriek tomu, že",
+	"preto, aby", "za účelom", "za týmto účelom", "skôr či neskôr ", "hneď ako", "len čo", "pokiaľ ide o", "pokiaľ nie",
+	"pokiaľ viem", "po prvé", "čo sa týka", "až do", "až na", "až po", "z tohto dôvodu", "z toho dôvodu", "no predsa",
+	"iba ak", "ak nie", "keď nie", "tobôž nie", "pravdu povediac", "ako napríklad", "okrem toho ", "v podstate", "ako je uvedené ",
+	"v každom prípade", "na rozdiel od", "v porovnaní s", "v oboch prípadoch", "stručne povedané", "inými slovami",
+	"na jednej strane", "na druhej strane", "s týmto cieľom" ];
+
+export const allWords = singleWords.concat( multipleWords );
+
+export default allWords;
+

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

@@ -0,0 +1,10 @@
+/** @module config/twoPartTransitionWords */
+
+/**
+ * Returns an array with two-part transition words to be used by the assessments.
+ * @returns {Array} The array filled with two-part transition words.
+ */
+export default [ [ "buď, buď" ], [ "buď, alebo" ], [ "ani, ani" ], [ "aj, aj" ], [ "tak, ako" ], [ "nielenže, lež aj" ],
+	[ "nielen, lež aj" ], [ "nielen, lež i" ], [ "nielenže, lež ai" ], [ "či, alebo" ], [ "i, i" ], [ "nielen, ale i" ],
+	[ "síce, ale" ] ];
+

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

@@ -0,0 +1,26 @@
+import {languageProcessing} from '../../../index';
+const {getClausesSplitOnStopWords, createRegexFromArray} = languageProcessing;
+
+import SlovakClause from '../values/Clause';
+import auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';
+import stopwords from '../config/stopWords.js';
+
+const options = {
+  Clause: SlovakClause,
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries),
+    stopCharacterRegex: /([:,])(?=[ \n\r\t'"+\-»«‹›<>])/gi,
+    stopwordRegex: createRegexFromArray(stopwords)
+  }
+};
+
+/**
+ * Gets the clauses from a sentence by determining sentence breakers.
+ *
+ * @param {string} sentence The sentence to split up into clauses.
+ *
+ * @returns {Array} The array with all clauses that have an auxiliary.
+ */
+export default function getSlovakClauses(sentence) {
+  return getClausesSplitOnStopWords(sentence, options);
+}

package/src/languageProcessing/languages/sk/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'), 'sk', false);
+
+  if (morphologyData) {
+    return word => stem(word, morphologyData);
+  }
+
+  return baseStemmer;
+}

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

@@ -0,0 +1,16 @@
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+/**
+ * Creates an array of participles found in a clause.
+ *
+ * @param {string} clauseText The clause to find participles in.
+ *
+ * @returns {Array} The list with participles found.
+ */
+export default function(clauseText) {
+  const words = getWords(clauseText);
+  const participleEndingsRegex = new RegExp('(ný|ní|tý|ná|tá|né|té)$');
+
+  return words.filter(word => participleEndingsRegex.test(word));
+}

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

@@ -0,0 +1,319 @@
+/* eslint-disable max-statements,complexity */
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Marek Šuppa
+ *
+ * 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 NON INFRINGEMENT. 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.
+ */
+
+/**
+ * Takes care of palatalisation.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}      The non-palatalised word or the original word if no such suffix is found.
+ */
+function palatalise( word, morphologyData ) {
+	const palatalEndingsRegexes = morphologyData.externalStemmer.palatalEndingsRegexes;
+	// Check if word ends in a palatal ending and return the regex if it does.
+	const checkPalatalEnding = palatalEndingsRegexes.find( regex => new RegExp( regex[ 0 ] ).test( word ) );
+	if ( checkPalatalEnding ) {
+		return word.replace( new RegExp( checkPalatalEnding[ 0 ] ), checkPalatalEnding[ 1 ] );
+	}
+	return word.slice( 0, -1 );
+}
+
+/**
+ * Removes case suffixes.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}     The word without case suffixes or the original word if no such suffix is found.
+ */
+function removeCases( word, morphologyData ) {
+	const caseSuffixes = morphologyData.externalStemmer.caseSuffixes;
+	const caseRegexes = morphologyData.externalStemmer.caseRegexes;
+
+	if ( word.length > 7 && word.endsWith( caseSuffixes.caseSuffix1 ) ) {
+		// Return the word without the suffix
+		return word.slice( 0, -5 );
+	}
+	if ( word.length > 6 && word.endsWith( caseSuffixes.caseSuffix2 ) ) {
+		return palatalise( word.slice( 0, -3 ), morphologyData );
+	}
+	if ( word.length > 5 ) {
+		if ( caseSuffixes.caseSuffixes3.includes( word.slice( -3 ) ) ) {
+			return palatalise( word.slice( 0, -2 ), morphologyData );
+		} else if ( caseSuffixes.caseSuffixes4.includes( word.slice( -3 ) ) ) {
+			return word.slice( 0, -3 );
+		}
+	}
+	if ( word.length > 4 ) {
+		if ( word.endsWith( caseSuffixes.caseSuffix5 ) ) {
+			return palatalise( word.slice( 0, -1 ), morphologyData );
+		} else if ( caseSuffixes.caseSuffixes6.includes( word.slice( -2 ) ) ) {
+			return palatalise( word.slice( 0, -2 ), morphologyData );
+		} else if ( caseSuffixes.caseSuffixes7.includes( word.slice( -2 ) ) ) {
+			return word.slice( 0, -2 );
+		}
+	}
+	if ( word.length > 3 ) {
+		if ( new RegExp( caseRegexes.caseRegex1 ).test( word ) ) {
+			return  palatalise( word, morphologyData );
+		} else if ( new RegExp( caseRegexes.caseRegex2 ).test( word ) ) {
+			return word.slice( 0, -1 );
+		}
+	}
+	return word;
+}
+
+/**
+ * Removes possessive suffixes.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}     The word without possessive suffixes or the original word if no such suffix is found.
+ */
+function removePossessives( word, morphologyData ) {
+	const possessiveSuffixes = morphologyData.externalStemmer.possessiveSuffixes;
+
+	if ( word.length > 5 ) {
+		if ( word.endsWith( possessiveSuffixes.posSuffixOv ) ) {
+			return word.slice( 0, -2 );
+		}
+		if ( word.endsWith( possessiveSuffixes.posSuffixIn ) ) {
+			return palatalise( word.slice( 0, -1 ), morphologyData );
+		}
+	}
+	return word;
+}
+
+/**
+ * Removes comparative and superlative affixes.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}     The word without comparative and superlative affixes or the original word if no such suffix is found.
+ */
+function removeComparativeAndSuperlative( word, morphologyData ) {
+	const superlativePrefix = morphologyData.externalStemmer.superlativePrefix;
+	if ( word.length > 6 && word.startsWith( superlativePrefix ) ) {
+		word = word.slice( 3, word.length );
+	}
+
+	if ( word.length > 5 ) {
+		const comparativeSuffixes = morphologyData.externalStemmer.comparativeSuffixes;
+		if ( comparativeSuffixes.includes( word.slice( -3 ) ) ) {
+			word = palatalise( word.slice( 0, -2 ), morphologyData );
+		}
+	}
+	return word;
+}
+
+/**
+ * Removes diminutive suffixes.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}      The word without diminutive suffixes or the original word if no such suffix is found.
+ */
+function removeDiminutives( word, morphologyData ) {
+	const diminutiveSuffixes = morphologyData.externalStemmer.diminutiveSuffixes;
+	if ( word.length > 7 && word.endsWith( diminutiveSuffixes.diminutiveSuffix1 ) ) {
+		return word.slice( 0, -5 );
+	}
+	if ( word.length > 6 ) {
+		if ( diminutiveSuffixes.diminutiveSuffixes2.includes( word.slice( -4 ) ) ) {
+			return palatalise( word.slice( 0, -3 ), morphologyData );
+		}
+		if ( diminutiveSuffixes.diminutiveSuffixes3.includes( word.slice( -4 ) ) ) {
+			return palatalise( word.slice( 0, -4 ), morphologyData );
+		}
+	}
+	if ( word.length > 5 ) {
+		if ( diminutiveSuffixes.diminutiveSuffixes4.includes( word.slice( -3 ) ) ) {
+			return palatalise( word.slice( 0, -3 ), morphologyData );
+		}
+		if ( diminutiveSuffixes.diminutiveSuffixes5.includes( word.slice( -3 ) ) ) {
+			return word.slice( 0, -3 );
+		}
+	}
+	if ( word.length > 4 ) {
+		if ( diminutiveSuffixes.diminutiveSuffixes6.includes( word.slice( -2 ) ) ) {
+			return palatalise( word.slice( 0, -1 ), morphologyData );
+		}
+		if ( diminutiveSuffixes.diminutiveSuffixes7.includes( word.slice( -2 ) ) ) {
+			return word.slice( 0, -1 );
+		}
+	}
+	if ( word.length > 3 && word.endsWith( "k" ) && ! word.endsWith( "isk" ) ) {
+		return word.slice( 0, -1 );
+	}
+	return word;
+}
+
+/**
+ * Removes augmentative suffixes.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}      The word without augmentative suffixes or the original word if no such suffix is found.
+ */
+function removeAugmentatives( word, morphologyData ) {
+	const augmentativeSuffixes = morphologyData.externalStemmer.augmentativeSuffixes;
+	if ( word.length > 6 && word.endsWith( augmentativeSuffixes.augmentativeSuffix1 ) ) {
+		return word.slice( 0, -4 );
+	}
+	if ( word.length > 5 && augmentativeSuffixes.augmentativeSuffixes2.includes( word.slice( -3 ) ) ) {
+		return palatalise( word.slice( 0, -2 ), morphologyData );
+	}
+	return word;
+}
+
+/**
+ * Removes derivational suffixes.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}       The word without derivational suffixes or the original word if no such suffix is found.
+ */
+function stemDerivational( word, morphologyData ) {
+	const derivationalSuffixes = morphologyData.externalStemmer.derivationalSuffixes;
+	if ( word.length > 8 && word.endsWith( derivationalSuffixes.derivationalSuffix1 ) ) {
+		return word.slice( 0, -6 );
+	}
+	if ( word.length > 7 ) {
+		if ( word.endsWith( derivationalSuffixes.derivationalSuffix2 ) ) {
+			return palatalise( word.slice( 0, -4 ), morphologyData );
+		}
+		if ( derivationalSuffixes.derivationalSuffixes3.includes( word.slice( -5 ) ) ) {
+			return word.slice( 0, -5 );
+		}
+	}
+	if ( word.length > 6 ) {
+		if ( derivationalSuffixes.derivationalSuffixes4.includes( word.slice( -4 ) ) ) {
+			return word.slice( 0, -4 );
+		}
+		if ( derivationalSuffixes.derivationalSuffixes5.includes( word.slice( -4 ) ) ) {
+			return palatalise( word.slice( 0, -3 ), morphologyData );
+		}
+	}
+	if ( word.length > 5 ) {
+		if ( word.endsWith( derivationalSuffixes.derivationalSuffix6 ) ) {
+			return word.slice( 0, -3 );
+		}
+		if ( derivationalSuffixes.derivationalSuffixes7.includes( word.slice( -3 ) ) ) {
+			return palatalise( word.slice( 0, -2 ), morphologyData );
+		}
+		if ( derivationalSuffixes.derivationalSuffixes8.includes( word.slice( -3 ) ) ) {
+			return word.slice( 0, -3 );
+		}
+	}
+	if ( word.length > 4 ) {
+		if ( derivationalSuffixes.derivationalSuffixes9.includes( word.slice( -2 ) ) ) {
+			return word.slice( 0, -2 );
+		}
+		if ( derivationalSuffixes.derivationalSuffixes10.includes( word.slice( -2 ) ) ) {
+			return palatalise( word.slice( 0, -1 ), morphologyData );
+		}
+	}
+	const derivationalRegex = new RegExp( morphologyData.externalStemmer.derivationalRegex );
+	if ( word.length > 3 && derivationalRegex.test( word ) ) {
+		return word.slice( 0, -1 );
+	}
+	return word;
+}
+
+/**
+ * Checks whether a word is in the full-form exception list and if so returns the canonical stem.
+ *
+ * @param {string} word	           				The word to be checked.
+ * @param {Object} exceptionListWithFullForms   The exception list to check.
+ *
+ * @returns {string}                The canonical stem if word was found on the list or the original word otherwise.
+ */
+const checkWordInFullFormExceptions = function( word, exceptionListWithFullForms ) {
+	for ( const paradigm of exceptionListWithFullForms ) {
+		if ( paradigm[ 1 ].includes( word ) ) {
+			return paradigm[ 0 ];
+		}
+	}
+	return null;
+};
+
+/**
+ * Checks whether a stem is in an exception list of words with multiple stems and if so returns the canonical stem.
+ *
+ * @param {string} stemmedWord	            The stemmed word to be checked.
+ * @param {Object} stemsThatBelongToOneWord The data that shows how non-canonical stems should be canonicalized.
+ *
+ * @returns {null|string} The canonical stem or null if nothing was found.
+ */
+const canonicalizeStem = function( stemmedWord, stemsThatBelongToOneWord ) {
+	for ( const paradigm of stemsThatBelongToOneWord ) {
+		if ( paradigm.includes( stemmedWord ) ) {
+			return paradigm[ 0 ];
+		}
+	}
+	return null;
+};
+
+/**
+ * Stems Slovak words.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Slovak morphology data.
+ *
+ * @returns {string}    The stemmed word.
+ */
+export default function stem( word, morphologyData ) {
+	// Return stem of words on the full forms exception list.
+	const stemFromExceptionListWithFullForms = checkWordInFullFormExceptions( word, morphologyData.exceptionLists.exceptionStemsWithFullForms );
+	if ( stemFromExceptionListWithFullForms ) {
+		return stemFromExceptionListWithFullForms;
+	}
+	// Remove case suffixes
+	word = removeCases( word, morphologyData );
+	// Remove possessive suffixes
+	word = removePossessives( word, morphologyData );
+	// Remove comparative and superlative affixes
+	word = removeComparativeAndSuperlative( word, morphologyData );
+	// Remove diminutive suffixes
+	word = removeDiminutives( word, morphologyData );
+	// Remove augmentative suffixes
+	word = removeAugmentatives( word, morphologyData );
+	// Remove derivational suffixes
+	word = stemDerivational( word, morphologyData );
+
+	// Return canonical stem of words that get a few different stems depending on the form.
+	const canonicalStem = canonicalizeStem( word, morphologyData.exceptionLists.stemsThatBelongToOneWord );
+	if ( canonicalStem ) {
+		return canonicalStem;
+	}
+
+	return word;
+}

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

@@ -0,0 +1,39 @@
+import {languageProcessing} from '../../../index';
+const {values} = languageProcessing;
+const {Clause} = values;
+import getParticiples from '../helpers/internal/getParticiples';
+import nonPassives from '../../sk/config/internal/nonPassives';
+
+/**
+ * Creates a Clause object for the Slovak language.
+ */
+class SlovakClause 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 {void}
+   */
+  checkParticiples() {
+    const foundParticiples = this.getParticiples().filter(
+      participle => !nonPassives.includes(participle)
+    );
+    this.setPassive(foundParticiples.length > 0);
+  }
+}
+
+export default SlovakClause;

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

@@ -0,0 +1,45 @@
+import {languageProcessing} from '../../../index';
+const {AbstractResearcher} = languageProcessing;
+
+// All config
+import firstWordExceptions from './config/firstWordExceptions';
+import {all as functionWords} from './config/functionWords';
+import transitionWords from './config/transitionWords';
+import twoPartTransitionWords from './config/twoPartTransitionWords';
+import keyphraseLength from './config/keyphraseLength';
+
+// All helpers
+import getStemmer from './helpers/getStemmer';
+import isPassiveSentence from './helpers/isPassiveSentence';
+
+/**
+ * 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);
+
+    // Delete the researches that are not available in Swedish.
+    delete this.defaultResearches.getFleschReadingScore;
+
+    Object.assign(this.config, {
+      language: 'sv',
+      passiveConstructionType: 'morphological',
+      firstWordExceptions,
+      functionWords,
+      transitionWords,
+      twoPartTransitionWords,
+      keyphraseLength
+    });
+
+    Object.assign(this.helpers, {
+      getStemmer,
+      isPassiveSentence
+    });
+  }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Returns an array with exceptions for the sentence beginning researcher.
+ *
+ * @returns {string[]} The array filled with exceptions.
+ */
+export default [
+	// Indefinite articles:
+	"ett",
+	// Definite articles:
+	"det", "den", "de",
+	// Numbers 1-10:
+	"en", "två", "tre", "fyra", "fem", "sex", "sju", "åtta", "nio", "tio",
+	// Demonstrative pronouns:
+	"denne", "denna", "detta", "dessa",
+];