Names.js

/**
 * Склонение русских имён и фамилий
 *
 * var rn = new RussianName('Паниковский Михаил Самуэльевич');
 * rn.fullName(rn.gcaseRod); // Паниковского Михаила Самуэльевича
 *
 * Список констант по падежам см. ниже в коде.
 *
 * Пожалуйста, присылайте свои уточнения мне на почту. Спасибо.
 *
 * @version  0.1.4
 * @author   Johnny Woo <agalkin@agalkin.ru>
 */

var RussianNameProcessor = {
    sexM: 'm',
    sexF: 'f',
    gcaseIm:   'nominative',      gcaseNom: 'nominative',      // именительный
    gcaseRod:  'genitive',        gcaseGen: 'genitive',        // родительный
    gcaseDat:  'dative',                                       // дательный
    gcaseVin:  'accusative',      gcaseAcc: 'accusative',      // винительный
    gcaseTvor: 'instrumentative', gcaseIns: 'instrumentative', // творительный
    gcasePred: 'prepositional',   gcasePos: 'prepositional',   // предложный

    rules: {
        lastName: {
            exceptions: [
                '   дюма,тома,дега,люка,ферма,гамарра,петипа,шандра . . . . .',
                '   гусь,ремень,камень,онук,богода,нечипас,долгопалец,маненок,рева,кива . . . . .',
                '   вий,сой,цой,хой -я -ю -я -ем -е'
            ],
            suffixes: [
                'f  б,в,г,д,ж,з,й,к,л,м,н,п,р,с,т,ф,х,ц,ч,ш,щ,ъ,ь . . . . .',
                'f  ска,цка  -ой -ой -ую -ой -ой',
                'f  ая       --ой --ой --ую --ой --ой',
                '   ская     --ой --ой --ую --ой --ой',
                'f  на       -ой -ой -у -ой -ой',

                '   иной -я -ю -я -ем -е',
                '   уй   -я -ю -я -ем -е',
                '   ца   -ы -е -у -ей -е',

                '   рих  а у а ом е',

                '   ия                      . . . . .',
                '   иа,аа,оа,уа,ыа,еа,юа,эа . . . . .',
                '   их,ых                   . . . . .',
                '   о,е,э,и,ы,у,ю           . . . . .',

                '   ова,ева            -ой -ой -у -ой -ой',
                '   га,ка,ха,ча,ща,жа  -и -е -у -ой -е',
                '   ца  -и -е -у -ей -е',
                '   а   -ы -е -у -ой -е',

                '   ь   -я -ю -я -ем -е',

                '   ия  -и -и -ю -ей -и',
                '   я   -и -е -ю -ей -е',
                '   ей  -я -ю -я -ем -е',

                '   ян,ан,йн   а у а ом е',

                '   ынец,обец  --ца --цу --ца --цем --це',
                '   онец,овец  --ца --цу --ца --цом --це',

                '   ц,ч,ш,щ   а у а ем е',

                '   ай  -я -ю -я -ем -е',
                '   гой,кой  -го -му -го --им -м',
                '   ой  -го -му -го --ым -м',
                '   ах,ив   а у а ом е',

                '   ший,щий,жий,ний  --его --ему --его -м --ем',
                '   кий,ый   --ого --ому --ого -м --ом',
                '   ий       -я -ю -я -ем -и',

                '   ок  --ка --ку --ка --ком --ке',
                '   ец  --ца --цу --ца --цом --це',

                '   в,н   а у а ым е',
                '   б,г,д,ж,з,к,л,м,п,р,с,т,ф,х   а у а ом е'
            ]
        },
        firstName: {
            exceptions: [
                '   лев    --ьва --ьву --ьва --ьвом --ьве',
                '   павел  --ла  --лу  --ла  --лом  --ле',
                'm  шота   . . . . .',
                'f  рашель,нинель,николь,габриэль,даниэль   . . . . .'
            ],
            suffixes: [
                '   е,ё,и,о,у,ы,э,ю   . . . . .',
                'f  б,в,г,д,ж,з,й,к,л,м,н,п,р,с,т,ф,х,ц,ч,ш,щ,ъ   . . . . .',

                'f  ь   -и -и . ю -и',
                'm  ь   -я -ю -я -ем -е',

                '   га,ка,ха,ча,ща,жа  -и -е -у -ой -е',
                '   а   -ы -е -у -ой -е',
                '   ия  -и -и -ю -ей -и',
                '   я   -и -е -ю -ей -е',
                '   ей  -я -ю -я -ем -е',
                '   ий  -я -ю -я -ем -и',
                '   й   -я -ю -я -ем -е',
                '   б,в,г,д,ж,з,к,л,м,н,п,р,с,т,ф,х,ц,ч    а у а ом е'
            ]
        },
        middleName: {
            suffixes: [
                '   ич   а  у  а  ем  е',
                '   на  -ы -е -у -ой -е'
            ]
        }
    },

    initialized: false,
    init: function() {
        if(this.initialized) return;
        this.prepareRules();
        this.initialized = true;
    },

    prepareRules: function() {
        for(var type in this.rules) {
            for(var key in this.rules[type]) {
                for(var i = 0, n = this.rules[type][key].length; i < n; i++) {
                    this.rules[type][key][i] = this.rule(this.rules[type][key][i]);
                }
            }
        }
    },

    rule: function(rule) {
        var m = rule.match(/^\s*([fm]?)\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*$/);
        if(m) return {
            sex: m[1],
            test: m[2].split(','),
            mods: [m[3], m[4], m[5], m[6], m[7]]
        }
        return false;
    },

    // склоняем слово по указанному набору правил и исключений
    word: function(word, sex, wordType, gcase) {
        // исходное слово находится в именительном падеже
        if(gcase == this.gcaseNom) return word;

        // составные слова
        if(word.match(/[-]/)) {
            var list = word.split('-');
            for(var i = 0, n = list.length; i < n; i++) {
                list[i] = this.word(list[i], sex, wordType, gcase);
            }
            return list.join('-');
        }

        // Иванов И. И.
        if(word.match(/^[А-ЯЁ]\.?$/i)) return word;

        this.init();
        var rules = this.rules[wordType];

        if(rules.exceptions) {
            var pick = this.pick(word, sex, gcase, rules.exceptions, true);
            if(pick) return pick;
        }
        var pick = this.pick(word, sex, gcase, rules.suffixes, false);
        return pick || word;
    },

    // выбираем из списка правил первое подходящее и применяем
    pick: function(word, sex, gcase, rules, matchWholeWord) {
        wordLower = word.toLowerCase();
        for(var i = 0, n = rules.length; i < n; i++) {
            if(this.ruleMatch(wordLower, sex, rules[i], matchWholeWord)) {
                return this.applyMod(word, gcase, rules[i]);
            }
        }
        return false;
    },

    // проверяем, подходит ли правило к слову
    ruleMatch: function(word, sex, rule, matchWholeWord) {
        if(rule.sex == this.sexM && sex == this.sexF) return false; // male by default
        if(rule.sex == this.sexF && sex != this.sexF) return false;
        for(var i = 0, n = rule.test.length; i < n; i++) {
            var test = matchWholeWord ? word : word.substr(Math.max(word.length - rule.test[i].length, 0));
            if(test == rule.test[i]) return true;
        }
        return false;
    },

    // склоняем слово (правим окончание)
    applyMod: function(word, gcase, rule) {
        switch(gcase) {
            case this.gcaseNom: var mod = '.'; break;
            case this.gcaseGen: var mod = rule.mods[0]; break;
            case this.gcaseDat: var mod = rule.mods[1]; break;
            case this.gcaseAcc: var mod = rule.mods[2]; break;
            case this.gcaseIns: var mod = rule.mods[3]; break;
            case this.gcasePos: var mod = rule.mods[4]; break;
            default: throw "Unknown grammatic case: "+gcase;
        }
        for(var i = 0, n = mod.length; i < n; i++) {
            var c = mod.substr(i, 1);
            switch(c) {
                case '.': break;
                case '-': word = word.substr(0, word.length - 1); break;
                default: word += c;
            }
        }
        return word;
    }
}

// new RussianName('Козлов Евгений Павлович')      // годится обычная форма
// new RussianName('Евгений Павлович Козлов')      // в таком виде тоже
// new RussianName('Козлов', 'Евгений')        // можно явно указать составляющие
// new RussianName('Кунтидия', 'Убиреко', '', 'f') // можно явно указать пол ('m' или 'f')
var RussianName = function(lastName, firstName, middleName, sex) {
    if(typeof firstName == 'undefined') {
        var m = lastName.match(/^\s*(\S+)(\s+(\S+)(\s+(\S+))?)?\s*$/);
        if(!m) throw "Cannot parse supplied name";
        if(m[5] && m[3].match(/(ич|на)$/) && !m[5].match(/(ич|на)$/)) {
            // Иван Петрович Сидоров
            lastName = m[5];
            firstName = m[1];
            middleName = m[3];
            this.fullNameSurnameLast = true;
        } else {
            // Сидоров Иван Петрович
            lastName = m[1];
            firstName = m[3];
            middleName = m[5];
        }
    }
    this.ln = lastName;
    this.fn = firstName || '';
    this.mn = middleName || '';
    this.sex = sex || this.getSex();
}
RussianName.prototype = {
    // constants
    sexM: RussianNameProcessor.sexM,
    sexF: RussianNameProcessor.sexF,
    gcaseIm:   RussianNameProcessor.gcaseIm,   gcaseNom: RussianNameProcessor.gcaseNom, // именительный
    gcaseRod:  RussianNameProcessor.gcaseRod,  gcaseGen: RussianNameProcessor.gcaseGen, // родительный
    gcaseDat:  RussianNameProcessor.gcaseDat,                                           // дательный
    gcaseVin:  RussianNameProcessor.gcaseVin,  gcaseAcc: RussianNameProcessor.gcaseAcc, // винительный
    gcaseTvor: RussianNameProcessor.gcaseTvor, gcaseIns: RussianNameProcessor.gcaseIns, // творительный
    gcasePred: RussianNameProcessor.gcasePred, gcasePos: RussianNameProcessor.gcasePos, // предложный

    fullNameSurnameLast: false,

    ln: '', fn: '', mn: '', sex: '',
    // если пол явно не указан, его можно легко узнать по отчеству
    getSex: function() {
        if(this.mn.length > 2) {
            switch(this.mn.substr(this.mn.length - 2)) {
                case 'ич': return this.sexM;
                case 'на': return this.sexF;
            }
        }
        return '';
    },

    fullName: function(gcase) {
        return (
            (this.fullNameSurnameLast ? '' : this.lastName(gcase) + ' ')
            + this.firstName(gcase) + ' ' + this.middleName(gcase) +
            (this.fullNameSurnameLast ? ' ' + this.lastName(gcase) : '')
        ).replace(/^ +| +$/g, '');
    },
    lastName: function(gcase) {
        return RussianNameProcessor.word(this.ln, this.sex, 'lastName', gcase);
    },
    firstName: function(gcase) {
        return RussianNameProcessor.word(this.fn, this.sex, 'firstName', gcase);
    },
    middleName: function(gcase) {
        return RussianNameProcessor.word(this.mn, this.sex, 'middleName', gcase);
    }
}