#67 [nouns][pl] declension

components/Declension.vue

@@ -0,0 +1,67 @@
+<template>
+    <span>
+        <template v-if="template">
+            <a href="#" @click.prevent="visible = !visible">{{ word }}</a>
+            <ul v-if="visible" class="list-unstyled small m-2 p-2 border">
+                <li v-for="(declined, c) in template.decline(word, plural)">
+                    <strong>{{c}} <small>({{cases[c]}})</small></strong> {{ declined.join(' / ') }}
+                </li>
+            </ul>
+        </template>
+        <template v-else>{{ word }}</template>
+    </span>
+</template>
+
+<script>
+    import { nounDeclensionTemplates } from "../src/data";
+    import cases from "../data/declension";
+
+    export default {
+        props: {
+            word: { required: true },
+            plural: { type: Boolean },
+            singularOptions: {  },
+        },
+        data() {
+            return {
+                template: this.findTemplate(),
+                cases,
+                visible: false,
+            }
+        },
+        methods: {
+            findTemplate() {
+                let longestMatch = 0;
+                let templates = [];
+                for (let t of nounDeclensionTemplates) {
+                    const matchLength = t.matches(this.word, this.plural);
+                    if (matchLength === 0) {
+                        continue;
+                    }
+                    if (matchLength > longestMatch) {
+                        longestMatch = matchLength;
+                        templates = [t];
+                    } else if (matchLength === longestMatch) {
+                        templates.push(t);
+                    }
+                }
+
+                if (!templates.length) {
+                    return null;
+                } else if (templates.length === 1) {
+                    return templates[0];
+                } else if (this.plural && this.singularOptions) {
+                    for (let t of templates) {
+                        for (let s of this.singularOptions) {
+                            if (t.matches(s)) {
+                                return t;
+                            }
+                        }
+                    }
+                }
+
+                return templates[0];
+            },
+        },
+    };
+</script>

locale/pl/declension.js

@@ -0,0 +1,9 @@
+export default {
+    M: 'kto? co?',
+    D: 'kogo? czego?',
+    C: 'komu? czemu?',
+    B: 'kogo? co?',
+    N: 'z kim? z czym?',
+    Msc: 'o kim? o czym?',
+    W: 'o!',
+}

locale/pl/nounDeclension.tsv

@@ -0,0 +1,51 @@
+M	D	C	B	N	Msc	W	M_pl	D_pl	C_pl	B_pl	N_pl	Msc_pl	W_pl
+aspi	aspi	aspi	aspi	aspim	aspi	aspi	aspi	aspich	aspi	aspi	aspimi	aspich	aspi
+enby	enby	enby	enby	enbym	enby	enby	enby/enbies	enbych	enby	enby/enbies	enbymi	enbych	enby/enbies
+hero	hera	heru	hero	herem	rze	hero	hera	her	herom	hera	herami	herach	hera
+magum	magum	magum	magum	magum	magum	magum	maga	magów	magom	maga	magami	magach	maga
+rze	rza	rzu	rze	rzem	rzu	rze	rza	rzy/rzów	rzom	rza	rzami	rzach	rza
+e	a	u	e	em	u	e	a	y	om	a	ami	ach	a
+cze	cza	czu	cze	czem	czu	cze	cza	czy	czom	cza	czami	czach	cza
+le	la	lu	le	lem	lu	le	la	li	lom	la	lami	lach	la
+że	ża	żu	że	żem	żu	że	ża	żów/ży	żom	ża	żami	żach	ża
+nie	nia	niu	nie	niem	niu	nie	nia	ń	niom	nia	niami	niach	nia
+cie	cia	ciu	cie	ciem	ciu	cie	cia	ć	ciom	cia	ciami	ciach	cia
+ke	ka	ku	ke	kiem	ku	ke	ka	ek	kom	ka	kami	kach	ka
+je	ja	ju	je	jem	ju	je	ja	jów	jom	ja	jami	jach	ja
+o	a	u	o	em	u	o	a	y	om	a	ami	ach	a
+ko	ka	ku	ko	kiem	ku	ko	ka	ek	kom	ka	kami	kach	ka
+wo	wa	wu	wo	wem	wie	wo	wa	wy	wom	wa	wami	wach	wa
+to	ta	tu	ta	tem	cie	to	ta	tów/t	tom	ta	tami	tach	ta
+io	ia	iu	io	iem	iu	io	ia	ii/iów	iom	ia	iami	iach	ia
+jo	ja	ju	jo	jem	ju	jo	ja	jów	jom	ja	jami	jach	ja
+ro	ra	rzu	ro	rem	rzu	ro	rza	rzy/rzów	rzom	rza	rzami	rzach	rza
+po	pa	pu	po	pem	pu	po	pa	pów	pom	pa	pami	pach	pa
+fo	fa	fu	fo	fem	fu	fo	fa	fów	fom	fa	fami	fach	fa
+czo	cza	czu	czo	czem	czu	czo	cza	czy	czom	cza	czami	czach	cza
+co	ca	cu	co	cem	cu	co	ca	c/ców	com	ca	cami	cach	ca
+no	na	nu	no	nem	nu	no	na	nów	nom	na	nami	nach	na
+lo	la	lu	lo	lem	lu	lo	la	li	lom	la	lami	lach	la
+ło	ła	łu	ło	łem	łu	ło	ła	ł	łom	ła	łami	łach	ła
+um	um	um	um	um	um	um	a	ów	om	a	ami	ach	a
+gum	gum	gum	gum	gum	gum	gum	ża	żów/ży	żom	ża	żami	żach	ża
+rum	rum	rum	rum	rum	rum	rum	rza	rzy/rzów	rzom	rza	rzami	rzach	rza
+ium	ium	ium	ium	ium	ium	ium	ia	ii/iów	iom	ia	iami	iach	ia
+tum	tum	tum	tum	tum	tum	tum	ta	tów/t	tom	ta	tami	tach	ta
+mum	mum	mum	mum	mum	mum	mum	ma	mów	mom	ma	mami	mach	ma
+kum	kum	kum	kum	kum	kum	kum	cza	czów/czy	czom	cza	czami	czach	cza
+ę	ęcia	ęciu	ę	ęciem	ęciu	ę	ęta	ąt	ętom	ęta	ętami	ętach	ęta
+we	wego	wemu	we	wym/wem	wym/wem	we	we	wych	wym	we	wymi	wych	we
+be	bego	bemu	be	bym/bem	bym/bem	be	be	bych	bym	be	bymi	bych	be
+ne	nego	nemu	ne	nym/nem	nym/nem	ne	ne	nych	nym	ne	nymi	nych	ne
+me	mego	memu	me	mym/mem	mym/mem	me	me	mych	mym	me	mymi	mych	me
+bóstwo	bóstwa	bóstwu	bóstwo	bóstwem	bóstwie	bóstwo	bóstwa	bóstw	bóstwom	bóstwa	bóstwami	bóstwach	bóstwa
+barmaństwo	barmaństwa	barmaństwu	barmaństwo	barmaństwem	barmaństwie	barmaństwo
+rodzeństwo	rodzeństwa	rodzeństwu	rodzeństwo	rodzeństwem	rodzeństwie	rodzeństwo
+koleżeństwo	koleżeństwa	koleżeństwu	koleżeństwo	koleżeństwem	koleżeństwie	koleżeństwo
+fanostwo	fanostwa	fanostwu	fanostwo	fanostwem	fanostwie	fanostwo
+kuzynostwo	kuzynostwa	kuzynostwu	kuzynostwo	kuzynostwem	kuzynostwie	kuzynostwo
+							dziabkowie	dziabków	dziabkom	dziabków	dziabkami	dziabkach	dziabkowie
+narzeczeństwo	narzeczeństwa	narzeczeństwu	narzeczeństwo	narzeczeństwem	narzeczeństwie	narzeczeństwo
+profesorstwo	profesorstwa	profesorstwu	profesorstwo	profesorstwem	profesorstwie	profesorstwo
+szefowstwo	szefowstwa	szefowstwu	szefowstwo	szefowstwem	szefowstwie	szefowstwo
+szwagrostwo	szwagrostwa	szwagrostwu		szwagrostwem	szwagrostwie	szwagrostwo

routes/nouns.vue

@@ -64,7 +64,7 @@
                     </thead>
                     <tbody>
                     <template v-if="visibleNouns().length">
-                    <tr v-for="noun in visibleNouns()" :class="{'mark-left': !noun.approved}">
+                    <tr v-for="noun in visibleNouns()" :class="{'mark-left': !noun.approved}" :key="noun.id">
                         <td>
                             <ul class="list-singular">
                                 <li v-for="w in noun.masc">{{ w }}</li>
@@ -108,10 +108,14 @@
                         </td>
                         <td>
                             <ul class="list-singular">
-                                <li v-for="w in noun.neutr">{{ w }}</li>
+                                <li v-for="w in noun.neutr">
+                                    <Declension :word="w"/>
+                                </li>
                             </ul>
                             <ul class="list-plural">
-                                <li v-for="w in noun.neutrPl">{{ w }}</li>
+                                <li v-for="w in noun.neutrPl">
+                                    <Declension :word="w" plural :singularOptions="noun.neutr"/>
+                                </li>
                             </ul>
 
                             <small v-if="noun.base && nouns[noun.base]">
@@ -289,7 +293,7 @@
         li {
             white-space: nowrap;
         }
-        li:before {
+        >li:before {
             content: "⋅";
             display: inline-block;
             width: $fa-fw-width;
@@ -302,7 +306,7 @@
         li {
             white-space: nowrap;
         }
-        li:before {
+        >li:before {
             content: "⁖";
             display: inline-block;
             width: $fa-fw-width;

src/classes.js

@@ -334,6 +334,64 @@ export class NounTemplate {
     }
 }
 
+
+export class NounDeclension {
+    constructor(endings) {
+        this.singular = {}
+        this.plural = {}
+        for (let k in endings) {
+            if (!endings.hasOwnProperty(k)) {
+                continue;
+            }
+            const value = endings[k] ? endings[k].split('/') : null;
+            if (k.endsWith('_pl')) {
+                this.plural[k.substr(0, k.length - 3)] = value;
+            } else {
+                this.singular[k] = value;
+            }
+        }
+    }
+
+    matches(word, plural) {
+        const plurality = plural ? 'plural' : 'singular';
+        const rep = Object.keys(this[plurality])[0];
+        for (let ending of this[plurality][rep] || []) {
+            if (word.endsWith(ending)) {
+                return ending.length;
+            }
+        }
+        return 0;
+    }
+
+    hasSingular() {
+        return Object.values(this.singular).filter(x => x !== null).length > 0;
+    }
+
+    hasPlural() {
+        return Object.values(this.plural).filter(x => x !== null).length > 0;
+    }
+
+    decline(word, plural) {
+        const plurality = plural ? 'plural' : 'singular';
+        const rep = Object.keys(this[plurality])[0];
+        const base = word.substring(0, word.length - this.matches(word, plural));
+        const options = this[plurality];
+
+        return buildDict(function*() {
+            for (let k in options) {
+                if (!options.hasOwnProperty(k)) {
+                    continue;
+                }
+                yield [
+                    k,
+                    options[k].map(o => base + o),
+                ];
+            }
+        });
+    }
+}
+
+
 export class Name {
     constructor(name, origin, meaning, usage, legally, pros, cons, notablePeople, count, links) {
         this.name = name;

src/data.js

@@ -1,4 +1,4 @@
-import { Source, Example, NounTemplate, TemplateGroup, TemplateLibrary, Name, Person } from './classes'
+import {Source, Example, NounTemplate, TemplateGroup, TemplateLibrary, Name, Person, NounDeclension} from './classes'
 import { buildDict, buildList } from './helpers';
 import { parseTemplates, getTemplate } from './buildTemplate';
 import sourcesForMultipleForms from '../data/sourcesMultiple';
@@ -121,3 +121,10 @@ export const people = buildList(function* () {
         );
     }
 });
+
+import nounDeclensionTemplatesRaw from '../data/nounDeclension.tsv';
+export const nounDeclensionTemplates = buildList(function* () {
+    for (let d of nounDeclensionTemplatesRaw) {
+        yield new NounDeclension(d);
+    }
+});