path: root/discord/ilo-kesi/function/index.js

"use strict";
/**
 * Parsing toki pona texts into sentences and sentence parts, and then into structured sentences that reflect the
 * structure of sitelen sitelen blocks.
 *
 * @type {{parse}}
 */
var sitelenParser = function () {
    'use strict';

    /**
     * Core parser into sitelen sitelen structure.
     * @param parseable a sentence to parse
     * @returns {*[]} a structured sentence array
     */
    function getSimpleStructuredSentence(parseable) {
        var tokens = parseable.split(' '),
            prepositions = ['tawa', 'tan', 'lon', 'kepeken', 'sama', 'poka'],
            objectMarker = ['li', 'e'],
            part = {part: 'subject', tokens: []},
            sentence = [part];

        tokens.forEach(function (token, index) {
            if (objectMarker.indexOf(token) > -1 &&
                index < tokens.length - 1) {
                sentence.push({part: 'objectMarker', sep: token, tokens: []});
                part = sentence[sentence.length - 1];
                return;
            } else if (prepositions.indexOf(token) > -1 && objectMarker.indexOf(tokens[index - 1]) === -1 &&
                index < tokens.length - 1 && objectMarker.indexOf(tokens[index + 1]) === -1) {
                sentence.push({part: 'prepPhrase', sep: token, tokens: []});
                part = sentence[sentence.length - 1];
                return;
            } else if (token === 'o' && part.tokens.length > 0) {
                // the o token should be in a container when it is used to address something, not in commands
                part.part = 'address';
                part.sep = 'o';
                sentence.push({part: 'subject', tokens: []});
                part = sentence[sentence.length - 1];
                return;
            } else if (token === 'a' && part.tokens.length > 0 && part.sep) {
                // the a token should never be in a container
                sentence.push({part: 'interjection', sep: null, tokens: [token]});
                part = sentence[sentence.length - 1];
                return;
            }

            part.tokens.push(token);

            if (allowedWords.indexOf(token) === -1){
                throw {type: 'illegal token', message: 'illegal token: ' + token};
            }
        });

        // filter out empty parts
        sentence = sentence.filter(function (part) {
            return part.tokens.length > 0;
        });
        return sentence;

    }

    /**
     * Preformats a given text, so that it splits it on punctuation marks.
     * @param text  text to preformat
     * @returns {{parsable: Array, raw: Array}} parsable array of raw text and punctuation
     */
    function preformat(text) {
        var result = text.match(/[^\.!\?#]+[\.!\?#]+/g),
            punctuation = ['.', ':', '?', '!', ','];

        var parsableParts = [], rawParts = [];
        if (!result) { // allow sentence fractions without any punctuation
            result = [text + (punctuation.indexOf(text) === -1 ? '|' : '')];
            // console.log('WARNING: sentence fraction without punctuation');
        }
        result.forEach(function (sentence) {
            sentence = sentence.trim();

            var parsableSentence = [];
            parsableParts.push(parsableSentence);
            rawParts.push(sentence);

            var body = sentence.substr(0, sentence.length - 1);

            // remove the comma before the la-clause and before a repeating li clause
            body = body.replace(', la ', ' la ');
            body = body.replace(', li ', ' li ');

            // split on context separators comma and colon
            var laparts = body.split(/ la /);
            laparts.forEach(function (lapart, index) {
                var colonparts = lapart.split(/:/);
                colonparts.forEach(function (colonpart, index) {
                    var commaparts = colonpart.split(/,/);
                    commaparts.forEach(function (commapart, index) {
                        commapart = commapart.trim();

                        parsableSentence.push({content: commapart});
                        if (index < commaparts.length - 1) {
                            parsableSentence.push({punctuation: ['comma']});
                        }
                    });

                    if (index < colonparts.length - 1) {
                        parsableSentence.push({punctuation: ['colon']});
                    }
                });
                if (laparts.length === 2 && index === 0) {
                    parsableSentence.push({punctuation: ['la']});
                }
            });

            var terminator = sentence.substr(-1);
            switch (terminator) {
                case '.':
                    parsableSentence.push({punctuation: ['period']});
                    break;
                case ':':
                    parsableSentence.push({punctuation: ['colon']});
                    break;
                case '!':
                    parsableSentence.push({punctuation: ['exclamation']});
                    break;
                case '?':
                    parsableSentence.push({punctuation: ['question']});
                    break;
                case '#':
                    parsableSentence.push({punctuation: ['banner']});
                    break;
                default:
                    break;
            }

        });
        return {parsable: parsableParts, raw: rawParts};
    }

    /**
     * Split proper names into Toki Pona syllables. It is assumed that the proper name follows standard Toki Pona rules.
     * @param properName the proper name string to split into syllables
     */
    function splitProperIntoSyllables(properName) {
        if (properName.length === 0) {
            return [];
        }

        var vowels = ['o', 'u', 'i', 'a', 'e'],
            allowed = ['o', 'u', 'i', 'a', 'e', 'mo', 'mu', 'mi', 'ma', 'me', 'no', 'nu', 'ni', 'na', 'ne', 'po', 'pu', 'pi', 'pa', 'pe', 'to', 'tu', 'ta', 'te', 'ko', 'ku', 'ki', 'ka', 'ke', 'so', 'su', 'si', 'sa', 'se', 'wi', 'wa', 'we', 'lo', 'lu', 'li', 'la', 'le', 'jo', 'ju', 'ja', 'je', 'on', 'un', 'in', 'an', 'en', 'mon', 'mun', 'min', 'man', 'men', 'non', 'nun', 'nin', 'nan', 'nen', 'pon', 'pun', 'pin', 'pan', 'pen', 'ton', 'tun', 'tan', 'ten', 'kon', 'kun', 'kin', 'kan', 'ken', 'son', 'sun', 'sin', 'san', 'sen', 'win', 'wan', 'wen', 'lon', 'lun', 'lin', 'lan', 'len', 'jon', 'jun'