axyseo 2.0.0-alpha.0.0.20 → 2.0.0-alpha.0.0.4

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

@@ -0,0 +1,3 @@
+export default {
+	recommendedLength: 25,
+};

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

@@ -0,0 +1,50 @@
+/**
+ * Returns a list with stopwords for the Portuguese passive voice assessment.
+ * @returns {Array} The list with stopwords.
+ */
+export default [
+	"que ",
+	"como",
+	"e",
+	"nem",
+	"se",
+	"caso",
+	"conforme",
+	"consoante",
+	"porque",
+	"pois",
+	"segundo ",
+	"enquanto",
+	"embora",
+	"conquanto",
+	"quanto menos",
+	"quanto mais",
+	"quando",
+	"mal ",
+	"apenas",
+	"ora",
+	"seja",
+	"quer",
+	"já",
+	"logo",
+	"portanto",
+	"por isso",
+	"pois",
+	"рог conseguinte",
+	"ou seja ",
+	"isto é",
+	"quer dizer",
+	"a saber",
+	"ou melhor",
+	"mas",
+	"também",
+	"sim",
+	"porém",
+	"contudo",
+	"senão",
+	"todavia",
+	"mas ainda",
+	"no entanto",
+	"entretanto",
+];
+

package/src/languageProcessing/languages/pt/config/syllables.json

@@ -0,0 +1,38 @@
+{
+  "vowels": "aeiouáéíóúàâêôãõü",
+  "deviations": {
+    "vowels": [
+      {
+        "fragments": [ "(gu|qu)[aeoáéíóúêã]" ],
+        "countModifier": -1
+      },
+      {
+        "fragments": [ "[^(g|q|a)][aeiou][aeo]$" ],
+        "countModifier": -1
+      },
+      {
+        "fragments": [ "[aeiouáéíóúàâêôü][aeo]", "[aeiou][íúáéóãê]" ],
+        "countModifier": 1
+      },
+      {
+        "fragments": [ "aí[ae]" ],
+        "countModifier": 1
+      }
+    ],
+    "words": {
+      "full": [
+        { "word": "delegacia", "syllables": 5 },
+        { "word": "democracia", "syllables": 5 },
+        { "word": "parceria", "syllables": 4 },
+        { "word": "secretaria", "syllables": 5 }
+      ],
+      "fragments": []
+    }
+  }
+}
+
+
+
+
+
+

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

@@ -0,0 +1,34 @@
+export const singleWords = [
+	"ademais", "afinal", "aliás", "analogamente", "anteriormente", "assim", "atualmente", "certamente", "conforme",
+	"conquanto", "contudo", "decerto", "embora", "enfim", "enquanto", "então", "entretanto", "eventualmente",
+	"igualmente", "inegavelmente", "inesperadamente", "mas", "ocasionalmente", "outrossim", "pois", "porquanto",
+	"porque", "portanto", "posteriormente", "precipuamente", "primeiramente", "primordialmente", "principalmente",
+	"salvo", "semelhantemente", "similarmente", "sobretudo", "surpreendentemente", "todavia", "logo", "inclusive",
+];
+
+export const multipleWords = [
+	"a fim de", "a fim de que", "a menos que", "a princípio", "a saber", "acima de tudo", "ainda assim", "ainda mais",
+	"ainda que", "além disso", "antes de mais nada", "antes de tudo", "antes que", "ao mesmo tempo", "ao passo que",
+	"ao propósito", "apesar de", "apesar disso", "às vezes", "assim como", "assim que", "assim sendo", "assim também",
+	"bem como", "com a finalidade de", "com efeito", "com o fim de", "com o intuito de", "com o propósito de",
+	"com toda a certeza", "como resultado", "como se", "da mesma forma", "de acordo com", "de conformidade com",
+	"de fato", "de maneira idêntica", "de tal forma que", "de tal sorte que", "depois que", "desde que", "dessa forma",
+	"dessa maneira", "desse modo", "do mesmo modo", "é provável", "em conclusão", "em contrapartida", "em contraste com",
+	"em outras palavras", "em primeiro lugar", "em princípio", "em resumo", "em seguida", "em segundo lugar", "em síntese",
+	"em suma", "em terceiro lugar", "em virtude de", "finalmente", "isto é", "já que", "juntamente com", "logo após",
+	"logo depois", "logo que", "mesmo que", "não apenas", "nesse hiato", "nesse ínterim", "nesse meio tempo", "nesse sentido",
+	"no entanto", "no momento em que", "ou por outra", "ou seja", "para que", "pelo contrário", "por analogia", "por causa de",
+	"por certo", "por conseguinte", "por consequência", "por conseqüência", "porém", "por exemplo", "por fim", "por isso", "por mais que",
+	"por menos que", "por outro lado", "por vezes", "posto que", "se acaso", "se bem que", "seja como for", "sem dúvida",
+	"sempre que", "só para exemplificar", "só para ilustrar", "só que", "sob o mesmo ponto de vista", "talvez provavelmente",
+	"tanto quanto", "todas as vezes que", "todas as vezes em que", "uma vez que", "visto que", "de repente",
+	"nada obstante", "não obstante", "de qualquer forma", "diga-se de passagem", "de qualquer jeito",
+	"de vez em quando", "aos poucos", "claro que", "no geral", "em geral", "geralmente", "subitamente", "a despeito de",
+	"em razão de", "em razão disso", "razão pela qual", "por essa razão", "por motivo de", "devido a", "em todo o caso", "de qualquer maneira",
+	"de todo modo", "de todo a modo", "de qualquer modo", "de forma que", "de modo que", "de tempos em tempos", "daí em diante", " daí por diante",
+	"de hoje em diante", "a partir de agora", "de agora em diante",
+];
+
+export const allWords = singleWords.concat( multipleWords );
+
+export default allWords;

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

@@ -0,0 +1,9 @@
+/**
+ * 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 [
+	[ "não apenas", "como também" ], [ "não só", "bem como" ], [ "não só", "como também" ],
+	[ "não só", "mas também" ], [ "ora", "ora" ], [ "ou", "ou" ], [ "quer", "quer" ],
+];
+

package/src/languageProcessing/languages/pt/helpers/calculateFleschReadingScore.js

@@ -0,0 +1,15 @@
+import { helpers } from "avadaseo";
+const { formatNumber } = helpers;
+
+/**
+ * Returns the Flesch reading score for Portuguese.
+ *
+ * @param {Object} statistics The Flesch reading statistics.
+ *
+ * @returns {number} The Flesch reading score for Portuguese.
+ */
+export default function calculateScore( statistics ) {
+	const score = 248.835 - ( 1.015 * statistics.averageWordsPerSentence ) - ( 84.6 * statistics.numberOfSyllables / statistics.numberOfWords );
+
+	return formatNumber( score );
+}

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

@@ -0,0 +1,29 @@
+import {languageProcessing} from '../../../index';
+const {createRegexFromArray, getClauses} = languageProcessing;
+
+import PortugueseClause from '../values/Clause';
+import auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';
+import stopwords from '../config/stopWords.js';
+const followingAuxiliaryExceptionWords = ['o', 'a', 'os', 'as', 'um', 'ums', 'uma', 'umas'];
+
+const options = {
+  Clause: PortugueseClause,
+  stopwords: stopwords,
+  auxiliaries: auxiliaries,
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries),
+    stopCharacterRegex: /([:,])(?=[ \n\r\t'"+\-»«‹›<>])/gi,
+    followingAuxiliaryExceptionRegex: createRegexFromArray(followingAuxiliaryExceptionWords)
+  }
+};
+
+/**
+ * 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 getPortugueseClauses(sentence) {
+  return getClauses(sentence, options);
+}

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

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

@@ -0,0 +1,35 @@
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+import participleStems from '../../config/internal/passiveVoiceParticiples';
+
+/**
+ * Checks if a Portuguese word is a participle.
+ * @param {string} word A Portuguese word.
+ * @returns {boolean} Returns true if word is a Portuguese participle, and false otherwise.
+ */
+function isParticiple(word) {
+  const participleSuffixes = ['a', 'o', 'as', 'os'];
+  // For each participle suffixes, check if the word ends in one of them.
+  return participleSuffixes.some(suffix => {
+    // Make sure only possible participles are targeted (minimum length being "> 3")
+    if (word.length > 3 && word.endsWith(suffix)) {
+      // If the word ends with one of the suffixes, retrieve the stem.
+      const stem = word.slice(0, -suffix.length);
+      // Check if the stem is in the list of participle stems: return true if it is, otherwise return false.
+      return participleStems.includes(stem);
+    }
+  });
+}
+
+/**
+ * Creates an array of participles for the participles found in a clause.
+ *
+ * @param {string} clauseText The clause to find participles in.
+ *
+ * @returns {Array} The list with participles.
+ */
+export default function getParticiples(clauseText) {
+  const words = getWords(clauseText);
+  return words.filter(word => isParticiple(word));
+}

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

@@ -0,0 +1,319 @@
+/* eslint-disable max-statements, complexity */
+
+/*
+Copyright (c) 2015, Luís Rodrigues
+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.
+*/
+
+import {languageProcessing} from '../../../index';
+const {findMatchingEndingInArray} = languageProcessing;
+
+/**
+ * Checks whether the character is a vowel.
+ *
+ * @param {string}	    character	The character to check.
+ * @param {string[]}    vowels      The Portuguese vowels.
+ *
+ * @returns {boolean}	Whether the character is a vowel.
+ */
+const isVowel = function(character, vowels) {
+  return vowels.includes(character);
+};
+
+/**
+ * Finds the first vowel in a string after the specified index and returns the index of the character following that vowel
+ * (if found).
+ *
+ * @param {string}	    word	    The word to check.
+ * @param {string[]}    vowels      The Portuguese vowels.
+ * @param {number}	    start       The index at which the search for a vowel should begin.
+ *
+ * @returns {number} The index of the character following the found vowel. If this is not found, the length of the word.
+ */
+const nextVowelPosition = function(word, vowels, start) {
+  const length = word.length;
+
+  for (let position = start; position < length; position++) {
+    if (isVowel(word[position], vowels)) {
+      return position;
+    }
+  }
+
+  return length;
+};
+
+/**
+ * Finds the first consonant in a string after the specified index and returns the index of the character following that
+ * consonant (if found).
+ *
+ * @param {string}	    word	The word to check.
+ * @param {string[]}    vowels  The Portuguese vowels.
+ * @param {number}	    start	The index at which the search for a consonant should begin.
+ *
+ * @returns {number} The index of the character following the found consonant. If this is not found, the length of the word.
+ */
+const nextConsonantPosition = function(word, vowels, start) {
+  const length = word.length;
+
+  for (let position = start; position < length; position++) {
+    if (!isVowel(word[position], vowels)) {
+      return position;
+    }
+  }
+
+  return length;
+};
+
+/**
+ * Replaces characters with other characters if found in a word.
+ *
+ * @param {string}		word				The word to check.
+ * @param {string[]}	charactersToReplace	The characters to replace.
+ * @param {string[]}	replacements		The replacement characters.
+ *
+ * @returns {string}	The word with the replacement characters, or the original word if no characters to replace were found.
+ */
+const replaceCharacters = function(word, charactersToReplace, replacements) {
+  for (let i = 0; i < charactersToReplace.length; i++) {
+    word = word.replace(charactersToReplace[i], replacements[i]);
+  }
+
+  return word;
+};
+
+/**
+ * Looks for the longest suffix in each group and removes it if it is found within the specified region (R1, R2 or RV).
+ * Once a suffix is found and removed, stops searching further.
+ *
+ * For some of the suffix groups, replaces the suffix with another string after removing it (e.g. -logia is replaced with
+ * -log).
+ *
+ * @param {string}	word	            The word to check.
+ * @param {Object}  standardSuffixData  The data for stemming standard suffixes.
+ * @param {string}	r1Text	            The text in the R1 region.
+ * @param {string}	r2Text	            The text in the R2 region.
+ * @param {string}	rvText	            The text in the RV region.
+ *
+ * @returns {string} The stemmed word or the original word if no suffix was removed.
+ */
+const stemStandardSuffixes = function(word, standardSuffixData, r1Text, r2Text, rvText) {
+  const regions = {
+    r1: r1Text,
+    r2: r2Text,
+    rv: rvText
+  };
+
+  for (const suffixGroup of standardSuffixData.standardGroups) {
+    const foundSuffix = findMatchingEndingInArray(
+      regions[suffixGroup.region],
+      suffixGroup.suffixes
+    );
+
+    if (foundSuffix) {
+      return word.slice(0, -foundSuffix.length) + suffixGroup.replacement;
+    }
+  }
+
+  const specialEnding = findMatchingEndingInArray(
+    regions[standardSuffixData.specialClass.region],
+    standardSuffixData.specialClass.suffixes
+  );
+  if (
+    findMatchingEndingInArray(word, standardSuffixData.specialClass.wordEndingsToCheck) &&
+    specialEnding
+  ) {
+    word = word.slice(0, -specialEnding.length) + standardSuffixData.specialClass.replacement;
+  }
+
+  return word;
+};
+
+/**
+ * Stems verb suffixes.
+ *
+ * @param {string}      word            The original word.
+ * @param {string[]}    verbSuffixes    The verb suffixes to check.
+ * @param {string}      rvText          The text of the RV.
+ *
+ * @returns {string} The word with the verb suffixes removed (if applicable).
+ */
+const stemVerbSuffixes = function(word, verbSuffixes, rvText) {
+  const verbSuffix = findMatchingEndingInArray(rvText, verbSuffixes);
+
+  if (verbSuffix !== '') {
+    word = word.slice(0, -verbSuffix.length);
+  }
+
+  return word;
+};
+
+/**
+ * Stems residual suffixes.
+ *
+ * @param {string}	word	            The word to check.
+ * @param {Object}  residualSuffixData  The data used to stem residual suffixes.
+ * @param {string}	rvText	            The text in the RV region.
+ *
+ * @returns {string} The word with a removed suffix, or the original input word if no suffix was removed.
+ */
+const stemResidualSuffixes = function(word, residualSuffixData, rvText) {
+  const foundSuffixUe = findMatchingEndingInArray(rvText, residualSuffixData.groupUe.suffixes);
+  const foundSuffixIe = findMatchingEndingInArray(rvText, residualSuffixData.groupIe.suffixes);
+  const foundSuffixE = findMatchingEndingInArray(rvText, residualSuffixData.groupESuffixes);
+
+  if (
+    foundSuffixUe &&
+    findMatchingEndingInArray(word, residualSuffixData.groupUe.wordEndingsToCheck)
+  ) {
+    word = word.slice(0, -foundSuffixUe.length);
+  } else if (
+    foundSuffixIe &&
+    findMatchingEndingInArray(word, residualSuffixData.groupIe.wordEndingsToCheck)
+  ) {
+    word = word.slice(0, -foundSuffixIe.length);
+  } else if (foundSuffixE) {
+    word = word.slice(0, -foundSuffixE.length);
+  } else if (word.endsWith(residualSuffixData.cCedilla[0])) {
+    word = word.slice(0, -1) + residualSuffixData.cCedilla[1];
+  }
+
+  return word;
+};
+
+/**
+ * Stems Portuguese words.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Object} morphologyData   The Portuguese morphology data.
+ *
+ * @returns {string} The stemmed word.
+ */
+export default function stem(word, morphologyData) {
+  word.toLowerCase();
+  const vowels = morphologyData.externalStemmer.vowels;
+
+  // Nasal vowels should be treated as a vowel followed by a consonant.
+  const nasalVowels = morphologyData.externalStemmer.nasalVowels.originals;
+  const nasalVowelsReplacement = morphologyData.externalStemmer.nasalVowels.replacements;
+  word = replaceCharacters(word, nasalVowels, nasalVowelsReplacement);
+
+  const length = word.length;
+  if (length < 2) {
+    return word;
+  }
+
+  let r1 = length;
+  let r2 = length;
+  let rv = length;
+
+  /*
+   * R1 is the region after the first non-vowel following a vowel, or is the null region at the end of the word if
+   * there is no such non-vowel.
+   */
+  for (let i = 0; i < length - 1 && r1 === length; i++) {
+    if (isVowel(word[i], vowels) && !isVowel(word[i + 1], vowels)) {
+      r1 = i + 2;
+    }
+  }
+
+  /*
+   * R2 is the region after the first non-vowel following a vowel in R1, or is the null region at the end of the
+   * word if there is no such non-vowel.
+   */
+  for (let i = r1; i < length - 1 && r2 === length; i++) {
+    if (isVowel(word[i], vowels) && !isVowel(word[i + 1], vowels)) {
+      r2 = i + 2;
+    }
+  }
+
+  /*
+   * If the second letter is a consonant, RV is the region after the next following vowel. If the first two letters are
+   * vowels, RV is the region after the next consonant, and otherwise (consonant-vowel case) RV is the region after the
+   * third letter. But RV is the end of the word if these positions cannot be found.
+   */
+  if (length > 3) {
+    if (!isVowel(word[1], vowels)) {
+      rv = nextVowelPosition(word, vowels, 2) + 1;
+    } else if (isVowel(word[0], vowels) && isVowel(word[1], vowels)) {
+      rv = nextConsonantPosition(word, vowels, 2) + 1;
+    } else {
+      rv = 3;
+    }
+  }
+
+  const r1Text = word.slice(r1);
+  const r2Text = word.slice(r2);
+  let rvText = word.slice(rv);
+
+  // Go through the first step of removing suffixes.
+  const wordAfterStep1 = stemStandardSuffixes(
+    word,
+    morphologyData.externalStemmer.standardSuffixes,
+    r1Text,
+    r2Text,
+    rvText
+  );
+
+  // If no suffixes were removed in the first step, search for and remove verb suffixes.
+  let wordAfterStep2 = '';
+
+  if (word === wordAfterStep1) {
+    wordAfterStep2 = stemVerbSuffixes(word, morphologyData.externalStemmer.verbSuffixes, rvText);
+  }
+
+  // If suffixes were removed in one of the previous steps, replace the word with the de-suffixed word and adjust RV text.
+  if (word !== wordAfterStep1) {
+    word = wordAfterStep1;
+    rvText = word.slice(rv);
+  } else if (word !== wordAfterStep2) {
+    word = wordAfterStep2;
+    rvText = word.slice(rv);
+  }
+
+  /*
+   * If a suffix was removed in one of the two previous steps, remove -i if preceded by -c and in RV. If no suffix was
+   * removed in one of the previous steps, remove -os, -a, -i, -o, -á, í, or ó if in RV.
+   */
+  if (wordAfterStep1 !== word || wordAfterStep2 !== word) {
+    if (
+      word.endsWith(morphologyData.externalStemmer.ciToC[0]) &&
+      rvText.endsWith(morphologyData.externalStemmer.ciToC[1])
+    ) {
+      word = word.slice(0, -1);
+      rvText = word.slice(rv);
+    }
+  } else {
+    const foundGeneralSuffix = findMatchingEndingInArray(
+      rvText,
+      morphologyData.externalStemmer.generalSuffixes
+    );
+    if (foundGeneralSuffix !== '') {
+      word = word.slice(0, -foundGeneralSuffix.length);
+      rvText = word.slice(rv);
+    }
+  }
+
+  // Stem residual suffixes, regardless of whether a suffix was removed in any of the previous steps or not.
+  word = stemResidualSuffixes(word, morphologyData.externalStemmer.residualSuffixes, rvText);
+
+  // Change the nasal vowel replacements back into the nasal vowels.
+  word = replaceCharacters(word, nasalVowelsReplacement, nasalVowels);
+
+  return word;
+}

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

@@ -0,0 +1,43 @@
+import {languageProcessing} from '../../../index';
+import {cannotDirectlyPrecedePassiveParticiple} from '../config/functionWords';
+import getParticiples from '../helpers/internal/getParticiples';
+const {directPrecedenceException, values} = languageProcessing;
+const {Clause} = values;
+
+/**
+ * Creates a Clause object for the Portuguese language.
+ */
+class PortugueseClause 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 clause = this.getClauseText();
+
+    const foundParticiples = this.getParticiples().filter(
+      participle =>
+        !directPrecedenceException(clause, participle, cannotDirectlyPrecedePassiveParticiple)
+    );
+
+    this.setPassive(foundParticiples.length > 0);
+  }
+}
+
+export default PortugueseClause;

package/src/languageProcessing/languages/ru/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 transitionWords from './config/transitionWords';
+import twoPartTransitionWords from './config/twoPartTransitionWords';
+import syllables from './config/syllables.json';
+import fleschReadingEaseScores from './config/fleschReadingEaseScores';
+import sentenceLength from './config/sentenceLength';
+
+// All helpers
+import getStemmer from './helpers/getStemmer';
+import isPassiveSentence from './helpers/isPassiveSentence';
+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: 'ru',
+      passiveConstructionType: 'morphological',
+      firstWordExceptions,
+      functionWords,
+      transitionWords,
+      twoPartTransitionWords,
+      syllables,
+      fleschReadingEaseScores,
+      sentenceLength
+    });
+
+    Object.assign(this.helpers, {
+      getStemmer,
+      isPassiveSentence,
+      fleschReadingScore
+    });
+  }
+}

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

@@ -0,0 +1,14 @@
+/**
+ *  Returns an array with exceptions for the sentence beginning researcher.
+ *  @returns {Array} The array filled with exceptions.
+ *  */
+export default [
+	// Numbers 1-10:
+	"один", "одна", "одно", "два", "две", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять",
+	// Demonstrative pronouns: тот, этот, такой, таков, столько
+	"этот", "этого", "этому", "этим", "этом", "эта", "этой", "эту", "это", "этого", "этому", "эти", "этих", "этим",
+	"этими", "тот", "того", "тому", "тем", "том", "та", "той", "ту", "те", "тех", "тем", "теми", "тех", "такой",
+	"такого", "такому", "таким", "такая", "такую", "такое", "такие", "таких", "таким", "такими", "стольких",
+	"стольким", "столько", "столькими", "вот",
+];
+