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

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

@@ -0,0 +1,22 @@
+import {get} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {baseStemmer} = languageProcessing;
+
+import determineStem from './internal/determineStem';
+
+/**
+ * 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'), 'de', false);
+
+  if (morphologyData) {
+    return word => determineStem(word, morphologyData);
+  }
+
+  return baseStemmer;
+}

package/src/languageProcessing/languages/de/helpers/internal/SentenceTokenizer.js

@@ -0,0 +1,31 @@
+import SentenceTokenizer from "../../../../helpers/sentence/SentenceTokenizer";
+import wordBoundaries from "../../../../../config/wordBoundaries";
+
+// The beginning of a string (^) or one of the word boundaries from the wordBoundaries helper.
+const wordBoundariesForRegex = "(^|[" + wordBoundaries().map( ( boundary ) => "\\" + boundary ).join( "" ) + "])";
+const ordinalDotRegex = new RegExp( wordBoundariesForRegex + "\\d{1,3}\\.$" );
+
+/**
+ * Class for tokenizing a (html) text into sentences.
+ */
+export default class GermanSentenceTokenizer extends SentenceTokenizer {
+	/**
+	 * Constructor
+	 * @constructor
+	 */
+	constructor() {
+		super();
+	}
+
+	/**
+	 * Checks whether a fullstop is an ordinal dot instead of a sentence splitter.
+	 * See: https://en.wikipedia.org/wiki/Ordinal_indicator#Ordinal_dot
+	 *
+	 * @param {string} currentSentence A string ending with a full stop.
+	 * @returns {boolean} Returns true if the full stop is an ordinal dot, false otherwise.
+	 */
+	endsWithOrdinalDot( currentSentence ) {
+		return ordinalDotRegex.test( currentSentence.trim() );
+	}
+}
+

package/src/languageProcessing/languages/de/helpers/internal/detectAndStemRegularParticiple.js

@@ -0,0 +1,128 @@
+import exceptionsParticiplesActive from "../../config/internal/exceptionsParticiplesActive";
+import exceptions from "../../config/internal/passiveVoiceRegex";
+
+/**
+ * Detects whether a word is a regular participle without a prefix and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle was matched.
+ */
+const detectAndStemParticiplesWithoutPrefixes = function( morphologyDataVerbs, word ) {
+	const geStemTParticipleRegex = new RegExp( "^" + morphologyDataVerbs.participleStemmingClasses[ 1 ].regex );
+	const geStemEtParticipleRegex = new RegExp( "^" + morphologyDataVerbs.participleStemmingClasses[ 0 ].regex );
+
+	/*
+	 * Check if it's a ge + stem ending in d/t + et participle.
+	 * As this is the more specific regex, it needs to be checked before the ge + stem + t regex.
+	 */
+	if ( geStemEtParticipleRegex.test( word ) ) {
+		// Remove the two-letter prefix and the two-letter suffix.
+		return ( word.slice( 2, word.length - 2 ) );
+	}
+
+	// Check if it's a ge + stem + t participle.
+	if ( geStemTParticipleRegex.test( word ) ) {
+		// Remove the two-letter prefix and the one-letter suffix.
+		return ( word.slice( 2, word.length - 1 ) );
+	}
+
+	return null;
+};
+
+/**
+ * Determines whether a given participle pattern combined with prefixes from a given class applies to a given word
+ * and if so, returns the stem.
+ *
+ * @param {string}      word        The word (not stemmed) to check.
+ * @param {string[]}    prefixes    The prefixes of a certain prefix class.
+ * @param {string}      regexPart   The regex part for a given class (completed to a full regex within the function).
+ * @param {number}      startStem   Where to start cutting off the de-prefixed word.
+ * @param {number}      endStem     Where to end cutting off the de-prefixed word (from the end index).
+ *
+ * @returns {string|null} The stem or null if no prefixed participle was matched.
+ */
+const detectAndStemParticiplePerPrefixClass = function( word, prefixes, regexPart, startStem, endStem ) {
+	for ( const currentPrefix of prefixes ) {
+		const participleRegex = new RegExp( "^" + currentPrefix + regexPart );
+
+		if ( participleRegex.test( word ) ) {
+			const wordWithoutPrefix = word.slice( currentPrefix.length - word.length );
+			const wordWithoutParticipleAffixes = wordWithoutPrefix.slice( startStem, wordWithoutPrefix.length - endStem );
+
+			return ( currentPrefix + wordWithoutParticipleAffixes );
+		}
+	}
+
+	return null;
+};
+
+/**
+ * Detects whether a word is a regular participle with a prefix and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle with prefix was matched.
+ */
+const detectAndStemParticiplesWithPrefixes = function( morphologyDataVerbs, word ) {
+	const prefixesSeparableOrInseparable = morphologyDataVerbs.prefixes.separableOrInseparable;
+
+	/*
+	 * It's important to preserve order here, since the ge + stem ending in d/t + et regex is more specific than
+	 * the ge + stem + t regex, and therefore must be checked first.
+	 */
+	for ( const participleClass of morphologyDataVerbs.participleStemmingClasses ) {
+		const regex = participleClass.regex;
+		const startStem = participleClass.startStem;
+		const endStem = participleClass.endStem;
+		const separable = participleClass.separable;
+
+		const prefixes = separable
+			? morphologyDataVerbs.prefixes.separable
+			: morphologyDataVerbs.prefixes.inseparable;
+
+		let stem = detectAndStemParticiplePerPrefixClass( word, prefixes, regex, startStem, endStem );
+
+		if ( stem ) {
+			return stem;
+		}
+
+		stem = detectAndStemParticiplePerPrefixClass( word, prefixesSeparableOrInseparable, regex, startStem, endStem );
+
+		if ( stem ) {
+			return stem;
+		}
+	}
+
+	return null;
+};
+
+/**
+ * Detects whether a word is a regular participle and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The participle stem or null if no regular participle was matched.
+ */
+export function detectAndStemRegularParticiple( morphologyDataVerbs, word ) {
+	if ( exceptions( word ).length > 0 || exceptionsParticiplesActive.includes( word ) ) {
+		return "";
+	}
+
+	let stem = detectAndStemParticiplesWithoutPrefixes( morphologyDataVerbs, word );
+
+	if ( stem ) {
+		return stem;
+	}
+
+	stem = detectAndStemParticiplesWithPrefixes( morphologyDataVerbs, word );
+
+	if ( stem ) {
+		return stem;
+	}
+
+	return null;
+}

package/src/languageProcessing/languages/de/helpers/internal/determineStem.js

@@ -0,0 +1,128 @@
+import {flatten} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {flattenSortLength} = languageProcessing;
+
+import {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';
+
+import stem from './stem';
+
+/**
+ * Returns a stem for a word that appears on the noun exception lists.
+ *
+ * @param {Object}  morphologyDataNouns The German morphology data for nouns.
+ * @param {string}  stemmedWord         The stem to check.
+ *
+ * @returns {string|null} The stemmed word or null if none was found.
+ */
+const findStemOnNounExceptionList = function(morphologyDataNouns, stemmedWord) {
+  const exceptionStems = morphologyDataNouns.exceptionStems;
+
+  for (const exceptionStemSet of exceptionStems) {
+    const matchedStem = exceptionStemSet.find(exceptionStem => stemmedWord.endsWith(exceptionStem));
+
+    if (matchedStem) {
+      const precedingLexicalMaterial = stemmedWord.slice(
+        0,
+        stemmedWord.length - matchedStem.length
+      );
+
+      return precedingLexicalMaterial + exceptionStemSet[0];
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Returns a stem for a word that appears on the adjective exception lists.
+ *
+ * @param {Object}  morphologyDataAdjectives    The German morphology data for adjectives.
+ * @param {string}  stemmedWord                 The stem to check.
+ *
+ * @returns {string|null} The stemmed word or null if none was found.
+ */
+const findStemOnAdjectiveExceptionList = function(morphologyDataAdjectives, stemmedWord) {
+  const adjectiveExceptionClasses = morphologyDataAdjectives.exceptions;
+
+  for (const key of Object.keys(adjectiveExceptionClasses)) {
+    const exceptionStems = adjectiveExceptionClasses[key];
+
+    for (const exceptionStemSet of exceptionStems) {
+      if (exceptionStemSet.includes(stemmedWord)) {
+        return exceptionStemSet[0];
+      }
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Returns a stem for a word that appears on the verb exception lists.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  stemmedWord         The stem to check.
+ *
+ * @returns {string|null} The stemmed word or null if none was found.
+ */
+const findStemOnVerbExceptionList = function(morphologyDataVerbs, stemmedWord) {
+  let wordToCheck = stemmedWord;
+  const strongAndIrregularVerbStems = morphologyDataVerbs.strongAndIrregularVerbs.stems;
+  const prefixes = flattenSortLength(morphologyDataVerbs.prefixes);
+
+  let matchedPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));
+
+  if (matchedPrefix) {
+    const wordWithoutPrefix = wordToCheck.slice(matchedPrefix.length, wordToCheck.length);
+
+    /* At least 3 characters so that e.g. "be" is not found in the stem "berg". A minimum length of 3 was chosen
+     * as a safe option, since 2-letter verb stems are highly unlikely to impossible.
+     */
+    if (wordWithoutPrefix.length > 2) {
+      wordToCheck = wordWithoutPrefix;
+    } else {
+      matchedPrefix = null;
+    }
+  }
+
+  for (const strongOrIrregularVerbParadigm of strongAndIrregularVerbStems) {
+    let stems = strongOrIrregularVerbParadigm.stems;
+    stems = flatten(Object.values(stems));
+
+    if (stems.includes(wordToCheck)) {
+      if (matchedPrefix) {
+        // The present tense stem is returned as a default stem.
+        return matchedPrefix + strongOrIrregularVerbParadigm.stems.present;
+      }
+
+      return strongOrIrregularVerbParadigm.stems.present;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Returns the stem for a given German input word.
+ *
+ * @param   {string} word                   The word to get the stem for.
+ * @param   {Object} morphologyDataGerman   The German morphology data.
+ *
+ * @returns {string} Stemmed form of the word.
+ */
+export default function determineStem(word, morphologyDataGerman) {
+  const verbData = morphologyDataGerman.verbs;
+  const stemmedWord = stem(verbData, word);
+
+  /*
+   * Goes through the stem exception functions from left to right, returns the first stem it finds.
+   * If no stem has been found, return the original, programmatically created, stem.
+   */
+  return (
+    findStemOnNounExceptionList(morphologyDataGerman.nouns, stemmedWord) ||
+    findStemOnAdjectiveExceptionList(morphologyDataGerman.adjectives, stemmedWord) ||
+    findStemOnVerbExceptionList(verbData, stemmedWord) ||
+    detectAndStemRegularParticiple(verbData, word) ||
+    stemmedWord
+  );
+}

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

@@ -0,0 +1,40 @@
+import {forEach} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+import regexFunctionFactory from '../../config/internal/passiveVoiceRegex.js';
+const regexFunction = regexFunctionFactory();
+import irregularParticiples from '../../config/internal/passiveVoiceIrregulars.js';
+
+const verbsBeginningWithErVerEntBeZerHerUber = regexFunction.verbsBeginningWithErVerEntBeZerHerUber;
+const verbsBeginningWithGe = regexFunction.verbsBeginningWithGe;
+const verbsWithGeInMiddle = regexFunction.verbsWithGeInMiddle;
+const verbsWithErVerEntBeZerHerUberInMiddle = regexFunction.verbsWithErVerEntBeZerHerUberInMiddle;
+const verbsEndingWithIert = regexFunction.verbsEndingWithIert;
+
+/**
+ * Creates German participles array for the participles found in a clause.
+ *
+ * @param {string} clauseText The clause to finds participles in.
+ *
+ * @returns {Array} The array with the German participles found.
+ */
+export default function(clauseText) {
+  const words = getWords(clauseText);
+
+  const foundParticiples = [];
+
+  forEach(words, function(word) {
+    if (
+      verbsBeginningWithGe(word).length !== 0 ||
+      verbsWithGeInMiddle(word).length !== 0 ||
+      verbsBeginningWithErVerEntBeZerHerUber(word).length !== 0 ||
+      verbsWithErVerEntBeZerHerUberInMiddle(word).length !== 0 ||
+      verbsEndingWithIert(word).length !== 0 ||
+      irregularParticiples.includes(word)
+    ) {
+      foundParticiples.push(word);
+    }
+  });
+  return foundParticiples;
+}

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

@@ -0,0 +1,215 @@
+/**
+ * @file German stemming algorithm. Adapted from:
+ * @author: Joder Illi
+ * @copyright (c) 2010, FormBlitz AG
+ * All rights reserved.
+ * Implementation of the stemming algorithm from http://snowball.tartarus.org/algorithms/german/stemmer.html
+ * Copyright of the algorithm is: Copyright (c) 2001, Dr Martin Porter and can be found at http://snowball.tartarus.org/license.php
+ *
+ * Redistribution and use in source and binary forms, with or without modification, is covered by the standard BSD license.
+ */
+/**
+ * Determines the start index of the R1 region.
+ * R1 is the region after the first non-vowel following a vowel. It should include at least 3 letters.
+ *
+ * @param {string} word The word for which to determine the R1 region.
+ * @returns {number} The start index of the R1 region.
+ */
+const determineR1 = function( word ) {
+	// Start with matching first vowel and non-vowel.
+	let r1Index = word.search( /[aeiouyäöü][^aeiouyäöü]/ );
+	// Then add 2 since the R1 index is the index after the first vowel & non-vowel matched with the regex.
+	if ( r1Index !== -1 ) {
+		r1Index += 2;
+	}
+
+	// Adjust R1 so that the region preceding it includes at least 3 letters.
+	if ( r1Index !== -1 && r1Index < 3 ) {
+		r1Index = 3;
+	}
+
+	return r1Index;
+};
+
+/**
+ * Search for the longest among the following suffixes,
+ * (a) em   ern   er
+ * (b) e   en   es
+ * (c) s (preceded by a valid s-ending)
+ * Define a valid s-ending as one of b, d, f, g, h, k, l, m, n, r or t.
+ *
+ * @param {string} word The word to check for the suffix.
+ * @returns {{index1: number, optionUsed1: string}} The index of the suffix and the kind of suffix used.
+ */
+const findSuffixStep1 = function( word ) {
+	const a1Index = word.search( /(em|ern|er)$/g );
+	const b1Index = word.search( /(e|en|es)$/g );
+	let c1Index = word.search( /([bdfghklmnrt]s)$/g );
+	// Exclude the s-ending before the s.
+	if ( c1Index !== -1 ) {
+		c1Index++;
+	}
+	let optionUsed1 = "";
+	let index1 = 10000;
+	if ( a1Index !== -1 ) {
+		optionUsed1 = "a";
+		index1 = a1Index;
+
+		return { index1, optionUsed1 };
+	} else if ( b1Index !== -1 ) {
+		optionUsed1 = "b";
+		index1 = b1Index;
+
+		return { index1, optionUsed1 };
+	} else if ( c1Index !== -1 ) {
+		optionUsed1 = "c";
+		index1 = c1Index;
+
+		return { index1, optionUsed1 };
+	}
+
+	return { index1, optionUsed1 };
+};
+
+/**
+ * Search for the longest among the following suffixes,
+ * (a) en   er   est
+ * (b) st (preceded by a valid st-ending, itself preceded by at least 3 letters)
+ * Define a valid st-ending as one of b, d, f, g, h, k, l, m, n or t.
+ *
+ * @param {string} word The word to check for the suffix.
+ * @returns {number} The index of the suffix.
+ */
+const findSuffixStep2 = function( word ) {
+	const a2Index = word.search( /(en|er|est)$/g );
+	let b2Index = word.search( /(.{3}[bdfghklmnt]st)$/g );
+	// Exclude the st-ending and the preceding 3 letters.
+	if ( b2Index !== -1 ) {
+		b2Index += 4;
+	}
+	let index2 = 10000;
+	if ( a2Index !== -1 ) {
+		index2 = a2Index;
+	} else if ( b2Index !== -1  ) {
+		index2 = b2Index;
+	}
+
+	return index2;
+};
+
+/**
+ * Delete the suffix found in step 1 if in R1. (The letter of the valid s-ending is not necessarily in R1.)
+ * If an ending of group (b) is deleted, and the ending is preceded by niss, delete the final s.
+ * (For example, äckern -> äck, ackers -> acker, armes -> arm, bedürfnissen -> bedürfnis).
+ *
+ * @param {string} word         The word for which to delete the suffix.
+ * @param {number} index1       The index of the suffix found in step 1.
+ * @param {string} optionUsed1  The type of the suffix found in step 1.
+ * @param {number} r1Index      The R1 index.
+ *
+ * @returns {string} The word with the deleted suffix.
+ */
+const deleteSuffix1 = function( word, index1, optionUsed1, r1Index ) {
+	if ( index1 !== 10000 && r1Index !== -1 ) {
+		if ( index1 >= r1Index ) {
+			word = word.substring( 0, index1 );
+			if ( optionUsed1 === "b" ) {
+				if ( word.search( /niss$/ ) !== -1 ) {
+					word = word.substring( 0, word.length - 1 );
+				}
+			}
+		}
+	}
+	return word;
+};
+
+/**
+ * Delete the suffix found in step 2 if in R1.
+ * (For example, derbsten -> derbst by step 1, and derbst -> derb by step 2,
+ * since b is a valid st-ending, and is preceded by just 3 letters).
+ *
+ * @param {string} word     The word for which to delete the suffix.
+ * @param {number} index2   The index of the suffix found in step 2.
+ * @param {number} r1Index  The R1 index.
+ *
+ * @returns {string} The word with the deleted suffix.
+ */
+const deleteSuffix2 = function( word, index2, r1Index ) {
+	if ( index2 !== 10000 && r1Index !== -1 ) {
+		if ( index2 >= r1Index ) {
+			word = word.substring( 0, index2 );
+		}
+	}
+	return word;
+};
+
+
+/**
+ * Stems irregular verbs.
+ *
+ * @param {Object} morphologyDataVerbs  The German morphology data for verbs.
+ * @param {string} word                 The word to stem.
+ *
+ * @returns {string} The stemmed word.
+ */
+const stemIrregularVerbs = function( morphologyDataVerbs, word ) {
+	const irregularVerbs = morphologyDataVerbs.veryIrregularVerbs;
+
+	const matchedParadigm = irregularVerbs.find( paradigm => {
+		const forms = paradigm.forms;
+		return forms.includes( word );
+	} );
+
+	if ( matchedParadigm ) {
+		return matchedParadigm.stem;
+	}
+
+	return null;
+};
+
+/**
+ * Stems German words.
+ *
+ * @param {Object} morphologyDataVerbs  The German morphology data for verbs.
+ * @param {string} word                 The word to stem.
+ *
+ * @returns {string} The stemmed word.
+ */
+export default function stem( morphologyDataVerbs, word ) {
+	// Check if word is a very irregular verb, and if so, return its stem.
+	const veryIrregularVerbStem = stemIrregularVerbs( morphologyDataVerbs, word );
+
+	if ( veryIrregularVerbStem ) {
+		return veryIrregularVerbStem;
+	}
+
+	// Put u and y between vowels into upper case.
+	word = word.replace( /([aeiouyäöü])u([aeiouyäöü])/g, "$1U$2" );
+	word = word.replace( /([aeiouyäöü])y([aeiouyäöü])/g, "$1Y$2" );
+	word = word.replace( /([aeiouyäöü])i([aeiouyäöü])/g, "$1I$2" );
+	word = word.replace( /([aeiouyäöü])e([aeiouyäöü])/g, "$1E$2" );
+
+	// Find the start index of the R1 region.
+	const r1Index = determineR1( word );
+
+	// Find suffixes as defined in step 1.
+	const index1 = findSuffixStep1( word ).index1;
+	const optionUsed1 = findSuffixStep1( word ).optionUsed1;
+
+	// Delete the suffix found in step 1.
+	word = deleteSuffix1( word, index1, optionUsed1, r1Index );
+
+	// Find suffixes as defined in step 2.
+	const index2 = findSuffixStep2( word );
+
+	// Delete the suffix found in step 2.
+	word = deleteSuffix2( word, index2, r1Index );
+
+	// Turn U and Y back into lower case.
+	word = word.replace( /U/g, "u" );
+	word = word.replace( /Y/g, "y" );
+	word = word.replace( /I/g, "i" );
+	word = word.replace( /E/g, "e" );
+
+	return word;
+}

package/src/languageProcessing/languages/de/helpers/memoizedSentenceTokenizer.js

@@ -0,0 +1,28 @@
+import { memoize } from "lodash";
+import SentenceTokenizer from "./internal/SentenceTokenizer";
+
+/**
+ * Returns the sentences from a certain text.
+ *
+ * @param {string} text 					The text to retrieve sentences from.
+ * @param {boolean} [trimSentences=true] 	Whether to trim whitespace from the beginning and end of the sentences or not.
+ *
+ * @returns {Array<string>} The list of sentences in the text.
+ */
+function getSentenceTokenizer( text, trimSentences = true ) {
+	const sentenceTokenizer = new SentenceTokenizer();
+	const { tokenizer, tokens } = sentenceTokenizer.createTokenizer();
+	sentenceTokenizer.tokenize( tokenizer, text );
+
+	return ( tokens.length === 0 ? [] : sentenceTokenizer.getSentencesFromTokens( tokens, trimSentences ) );
+}
+
+/*
+ * The second argument to the memoize function is a so-called resolver function.
+ * It creates a cache key consisting of a combination of all arguments to a function.
+ * This is needed because by default, only the first argument to a function is used as the map cache key by the memoize function.
+ * This means that a function is only re-run if the value of the first argument changes.
+ * We want to re-run the getSentenceTokenizer function also when only the second argument changes to prevent cache collisions.
+ * @see https://lodash.com/docs/4.17.15#memoize
+ */
+export default memoize( getSentenceTokenizer, ( ...args ) => JSON.stringify( args ) );

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

@@ -0,0 +1,85 @@
+import {includes, map} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {indices, values} = languageProcessing;
+const {getIndicesByWord, getIndicesByWordList} = indices;
+const {Clause} = values;
+
+import getParticiples from '../helpers/internal/getParticiples';
+import exceptionsParticiplesActive from '../config/internal/exceptionsParticiplesActive.js';
+import {participleLike as participleLikeAuxiliaries} from '../config/internal/passiveVoiceAuxiliaries.js';
+
+const exceptionsRegex = /\S+(apparat|arbeit|dienst|haft|halt|keit|kraft|not|pflicht|schaft|schrift|tät|wert|zeit)($|[ \n\r\t.,'()"+-;!?:/»«‹›<>])/gi;
+
+/**
+ * Creates a Clause object for the German language.
+ */
+class GermanClause 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 => {
+      return (
+        !this.hasNounSuffix(participle) &&
+        !includes(exceptionsParticiplesActive, participle) &&
+        !this.hasHabenSeinException(participle) &&
+        !includes(participleLikeAuxiliaries, participle)
+      );
+    });
+
+    this.setPassive(foundParticiples.length > 0);
+  }
+
+  /**
+   * Checks whether a found participle ends in a noun suffix.
+   * If a word ends in a noun suffix from the exceptionsRegex, it isn't a participle.
+   *
+   * @param {string} participle   The participle to check.
+   *
+   * @returns {boolean} Returns true if it ends in a noun suffix, otherwise returns false.
+   */
+  hasNounSuffix(participle) {
+    return participle.match(exceptionsRegex) !== null;
+  }
+
+  /**
+   * Checks whether a participle is followed by 'haben' or 'sein'.
+   * If a participle is followed by one of these, the clause is not passive.
+   *
+   * @param {string} participle   The participle to check.
+   *
+   * @returns {boolean} Returns true if it is an exception, otherwise returns false.
+   */
+  hasHabenSeinException(participle) {
+    const participleIndices = getIndicesByWord(participle, this.getClauseText());
+    let habenSeinIndices = getIndicesByWordList(['haben', 'sein'], this.getClauseText());
+
+    // Don't check further if there is no participle or no haben/sein.
+    if (participleIndices.length === 0 || habenSeinIndices.length === 0) {
+      return false;
+    }
+
+    habenSeinIndices = map(habenSeinIndices, 'index');
+    const currentParticiple = participleIndices[0];
+    return includes(habenSeinIndices, currentParticiple.index + currentParticiple.match.length + 1);
+  }
+}
+
+export default GermanClause;