Documentation de JSrealB

Chargement des ressources

Pour fonctionner, JSrealB a besoin de ressources qui sont le lexique, les tables de règles et une liste de constantes. Ces ressources doivent être chargées avant toute réalisation à l'aide de JSrealLoader() comme dans l'exemple qui suit que vous avez pu voir fonctionner en entrant sur cette page :

                var URL = {
                    lexicon:  {
                        fr: "../data/lex-fr.min.json",
                        en: "../data/lex-en.min.json"
                    },
                    rule: {
                        fr: "../data/rule-fr.min.json",
                        en: "../data/rule-en.min.json"
                    },
                    feature: "../data/feature.min.json"
                };

                JSrealLoader({
                    language: "fr",
                    lexiconUrl: URL.lexicon.fr,
                    ruleUrl: URL.rule.fr,
                    featureUrl: URL.feature
                }, function() {
                    alert(
                        S(
                            NP(N("madame").cap().a(","), N("monsieur").cap().a(",")),
                            NP(Pro("je").pe(1)),
                            VP(V("vouloir").t("c"), NP(Pro("me").n("p").pe(2)), SP(VP(V("présenter")), NP(D("le"), N("programme"), "JSrealB")))
                        ).a("!")
                    );
                }, function(errorMessage) {
                    alert(errorMessage);
                });
            

Dans la plupart des cas, on peut simplifier le chargement des ressources en appelant la fonction loadLanguage(dataDir,language,fn)

Vocabulaire

Extension du lexique

Le lexique peut être étendu selon vos besoins. Pour ajouter du vocabulaire au lexique, vous pouvez écrire directement dans le lexique ou en ajouter dynamiquement.

Exemple : Nous voulons ajouter le nom propre JSrealB au lexique français.

Dans tous les cas, les étapes sont les suivantes :

1. Nous le faisons dynamiquement et nous testons le résultat.

JSrealB.Config.get("lexicon")["JSrealB"] = { "N": { "g": "m", "pe": 3, "tab": ["nI"] } }; alert( S(NP(N("JSrealB")), VP(V("être").t("p"), NP(D("un"), N("programme")))) );

2. L'alternative est de le faire durablement en l'ajoutant au lexique, pour cela, il faut modifier le JSON ou insérer le vocabulaire au niveau des scripts qui gèrent la génération des ressources.

Créer une nouvelle table de règles

Chaque élément du lexique est relié à une ou plusieurs table de règles de transformations. Une règle peut être une transformation nulle, c'est-à-dire, consistant à ne rien transformer (voir l'exemple de la table pp).

Les tables de flexions suivent un modèle contenant les informations suivantes :

A noter que les tables sont classées dans des catégories (conjugation, declension, regular, ponctuation, date, number...)

Nouvelle langue

Pour ajouter une nouvelle langue, il faut définir un nouveau lexique, de nouvelles tables de règles pour les flexions et autres transformations sur le même modèle que ceux proposés en français et en anglais.

Flexion

Elements terminaux

Nom Représentation syntaxique Exemple en français Exemple en anglais
Représentation syntaxique Réalisation Représentation syntaxique Réalisation
Nom N(...) N("joueur") N("player")
Adjectif A(...) A("grand") A("tall")
Pronom Pro(...) Pro("je") Pro("I")
Déterminant D(...) D("le") D("the")
Verbe V(...) V("apprendre") V("learn")
Adverbe Adv(...) Adv("bien") Adv("well")
Préposition P(...) P("vers") P("toward")
Conjonction C(...) C("et") C("and")
Texte brut "..." "mots entre guillemets ajoutés sans modifications à la réalisation" "mots entre guillemets ajoutés sans modifications à la réalisation" "verbatim" "verbatim"

Syntagmes

Nom Représentation syntaxique Exemple en français Exemple en anglais
Représentation syntaxique Réalisation Représentation syntaxique Réalisation
Phrase S(...) S(NP(Pro("je")), VP(V("dormir").t("p"))) S(NP(Pro("I")), VP(V("sleep").t("p")))
Syntagme nominal NP(...) NP(D("le"), N("voiture")) NP(D("the"), N("car"))
Syntagme adjectival AP(...) AP(Adv("très"), A("grand")) AP(Adv("very"), A("tall"))
Syntagme Adverbial AdvP(...) AdvP(Adv("bien"), Adv("heureusement")) AdvP(Adv("far"), Adv("back"))
Syntagme verbal VP(...) VP(V("apprendre").t("p"), NP(D("le"), N("course"))) VP(V("enjoy"), NP(D("a"), N("meal")))
Syntagme prépositionnel PP(...) PP(P("à"), NP(N("minuit"))) PP(P("at"), NP(N("midnight")))
Syntagme propositionnel SP(...) SP(Pro("dont"), S(NP(Pro("je")), VP(V("parler")).t("p"))) SP(Pro("where"), S(NP(Pro("I")), VP(V("live")).t("p")))
Syntagme coordonné CP(...) CP(C("et"), AP(A("vaillant")), AP(A("gentil")), AP(A("serviable"))) CP(C("and"), AP(A("kind")), AP(A("beautiful")))
Texte brut dans un syntagme XX(Y(...), "...") NP(N("valeur").a(":"), "1, 2 ou 3") NP("no more", N("bottle").n("p"))

Transformations

Ces options sont transmises de syntagme en syntagme jusqu'aux éléments terminaux

Transformation Description Cas d'utilisation en français Réalisation en français Cas d'utilisation en anglais Réalisation en anglais
Conjonction C(" ") | .c(" ")
.c(" ") CP(N("mademoiselle"), N("madame"), N("monsieur")).c("ou") CP(N("boy"), N("girl")).c("or")
C(" ") CP(C("ou"), N("madame"), N("monsieur")) CP(C("or"), N("man"), N("woman"))
Absence CP(N("madame"), N("monsieur")) CP(N("man"), N("woman"))
Temps .t("p") Le temps par défaut est l'infinitif
p présent V("avoir").t("p") V("have").t("p")
i imparfait V("avoir").t("i")
ps passé simple V("avoir").t("ps") V("have").t("ps")
f futur V("avoir").t("f")
ip impératif présent V("avoir").t("ip").pe(2)
ps conditionnel présent V("avoir").t("c")
pr participe présent V("avoir").t("pr") V("have").t("pr")
s subjonctif présent V("avoir").t("s")
si subjonctif imparfait V("avoir").t("si")
pp participe passé V("avoir").t("pp") V("have").t("pp")
Personne .pe(3) La personne par défaut est la 3ème
1 Verbe à la première personne du singulier V("avoir").t("p").pe(1) V("be").t("p").pe(1)
2 Verbe à la deuxième personne du singulier V("avoir").t("p").pe(2) V("be").t("p").pe(2)
3 Verbe à la troisième personne du singulier V("avoir").t("p").pe(3) V("be").t("p").pe(3)
1 Verbe à la première personne du pluriel V("avoir").t("p").pe(1).n("p") V("be").t("p").pe(1).n("p")
2 Verbe à la deuxième personne du pluriel V("avoir").t("p").pe(2).n("p") V("be").t("p").pe(2).n("p")
3 Verbe à la troisième personne du pluriel V("avoir").t("p").pe(3).n("p") V("be").t("p").pe(3).n("p")
Nombre .n("s") Le nombre par défaut est le singulier
s Verbe au singulier V("manger").t("p").n("s") V("eat").t("p").n("s")
s Nom au singulier N("joueur").n("s") N("player").n("s")
s Adjectif au singulier ou au superlatif A("grand").n("s") A("tall").f("su")
s Déterminant au singulier D("le").n("s") D("a").n("s")
p Verbe au pluriel V("manger").t("p").n("p") V("have").t("p").n("p")
p Nom au pluriel N("joueur").n("p") N("player").n("p")
p Adjectif au pluriel ou au comparatif A("grand").n("p") A("tall").f("co")
p Déterminant au pluriel D("le").n("p") D("a").n("p")
Genre .g("m") Le genre par défaut est le masculin
m Nom au masculin N("joueur").g("m")
m Adjectif au masculin A("grand").g("m")
m Déterminant au masculin D("le").g("m")
f Nom au féminin N("joueur").g("f")
f Adjectif au féminin A("grand").g("f")
f Déterminant (adjectif possessif) au féminin D("mon").g("f").pe(1)

Pronoms

Le pronoms qui sont dans le lexique sont à la 1ère personne du singulier. Pour obtenir les autres, il faut décliner la forme de base comme suit

)
Pronom Déclinaison Représentation française Réalisation Représentation anglaise Réalisation
Pronom personnel sujet 1ère personne du singulier Pro("je").pe(1) Pro("I").pe(1)
2ème personne du singulier Pro("je").pe(2) Pro("I").pe(2)
3ème personne du singulier Pro("je").pe(3) Pro("I").pe(3)
3ème personne au féminin singulier Pro("je").pe(3).g("f") Pro("I").pe(3).g("f")
3ème personne neutre Pro("I").pe(3).g("n")
1ère personne du pluriel Pro("je").pe(1).n("p") Pro("I").pe(1).n("p")
2ème personne du pluriel Pro("je").pe(2).n("p") Pro("I").pe(2).n("p")
3ème personne du pluriel Pro("je").pe(3).n("p") Pro("I").pe(3).n("p")
3ème personne au féminin pluriel Pro("je").pe(3).n("p").g("f")
Pronom personnel accentué 1ère personne du singulier Pro("moi").pe(1) Pro("me").pe(1)
2ème personne du singulier Pro("moi").pe(2) Pro("me").pe(2)
3ème personne du singulier Pro("moi").pe(3) Pro("me").pe(3)
3ème personne du singulier au féminin Pro("moi").pe(3).g("f") Pro("me").pe(3).g("f")
3ème personne neutre Pro("me").pe(3).g("n")
1ère personne du pluriel Pro("moi").pe(1).n("p") Pro("me").pe(1).n("p")
2ème personne du pluriel Pro("moi").pe(2).n("p") Pro("me").pe(2).n("p")
3ème personne du pluriel Pro("moi").pe(3).n("p") Pro("me").pe(3).n("p")
3ème personne du pluriel au féminin Pro("moi").pe(3).n("p").g("f")

Ca fonctionne de la même façon pour d'autres pronoms comme moi-même et me en français, ainsi que me, mine et myself en anglais.

Le principe est le même pour les déterminants, par exemple mon en français et my en anglais.

Mise en forme

La ponctuation disponible dépend du contenu du lexique.

Ponctuation

Option Description Cas d'utilisation en français Réalisation Cas d'utilisation en anglais Réalisation
.b() Ajouter un tiret avant N("homme").b("-") N("man").b("-")
Ajouter une étoile avant N("homme").b("*") N("man").b("*")
.a() Ajouter un point après N("homme").a(".") N("man").a(".")
Ajouter un point d'exclamation après N("homme").a("!") N("man").a("!")
Ajouter un point virgule après un mot NP(D("un").a(";"), N("homme")) NP(D("a").a(";"), N("man"))
Ajouter des points de suspension après un mot N("homme").a("...") N("man").a("...")
.en() Entourer de parenthèses N("homme").en("(") N("man")
Entourer de parenthèses (alternative) N("homme").en(")") N("man").en(")")
Entourer de crochets N("homme").en("[") N("man").en("[")
Entourer d'étoiles N("homme").en("*") N("man").en("*")

Casse

Option Description Cas d'utilisation en français Réalisation Cas d'utilisation en anglais Réalisation
cap() Première lettre en majuscule N("joueur").cap() N("player").cap()

HTML

Option Description Cas d'utilisation en français Réalisation Cas d'utilisation en anglais Réalisation
tag(nom,{attributs}) Balise HTML autour d'une construction N("joueur").tag("i",{"style":"text-decoration:underline"}) N("player").tag("b",{"title":"the best",style:"color:blue"})

Date

Le module Date accepte en entrée une chaine de caractères ou un objet Date.

Création

Description Représentation syntaxique Réalisation en français Réalisation en anglais
Date courante DT()
Date courante (alternative) DT(new Date())
Date dans le passé DT("2014-11-21T21:00:00")
Date dans le passé (alternative) DT(new Date("2014-11-21T21:00:00"))
Date dans le futur DT("2028-11-21T21:30:00")
Date dans le futur (alternative) DT(new Date("2028-11-21T21:30:00"))
Fuseau horaire DT("2014-11-21T11:00:00+00:00")
Fuseau horaire (alternative) DT(new Date("2014-11-21T11:00:00+00:00"))

Format de la date d'entrée

DT() utilise l'objet JavaScript Date()

La chaine de caractères en entrée doit être dans un format reconnu par la méthode Date.parse(), donc dans le format IETF-compliant RFC 2822 ou ISO8601.

Attention: Le comportement de l'objet Date() diffère selon le navigateur. Il est fortement conseillé de fixer le fuseau horaire sinon il sera déterminé par le navigateur (voir ci-dessous).

Norme Format Description Représentation syntaxique Réalisation en français Réalisation en anglais
ISO 8601 YYYY-MM-DDTHH:mm(:ss)+TZ Heure selon le fuseau horaire choisi en entrée, heure locale en sortie DT("2015-01-02T00:00:00+00:00")
aaaa-mm-jj Si l'heure n'est pas indiquée, ce sera minuit GMT et l'heure locale en sortie DT("2015-01-02")
aaaa-mm-jjThh:ii:ss Attention: Par défaut, le fuseau horaire en entrée est le fuseau horaire du système (sous firefox) alors que pour Safari ce sera l'heure GMT par défaut, dans tous les cas, c'est l'heure locale en sortie DT("2015-01-02T00:00:00")
RFC 2822 YYYY/MM/DD HH:mm(:ss) +ZZZZ Heure selon le fuseau horaire choisi en entrée, heure locale en sortie DT("2015/01/02 00:00:00 +0000")
YYYY/MM/DD Si l'heure n'est pas indiquée, ce sera minuit heure système (heure locale) DT("2015/01/02")
YYYY/MM/DD HH:mm(:ss) Par défaut, le fuseau horaire en entrée est le fuseau horaire du système, heure locale en sortie DT("2015/01/02 00:00:00")

Options d'affichage

Option (avec valeur par défaut) Description Cas d'utilisation Réalisation en français Réalisation en anglais
.dOpt({nat: true}) ou nat() Date en toutes lettres DT(new Date()).nat()
Dates en chiffres DT(new Date()).nat(false)
.dOpt({year: true, month: true, date: true, day: true, hour: true, minute: true, second: true}) Affichage de la date sans l'heure DT().dOpt({hour: false, minute: false, second: false})
Affichage de l'heure DT().dOpt({year: false, month: false, date: false, day: false})
Affichage de l'heure et des minutes DT().dOpt({year: false, month: false, date: false, day: false, second: false})
Affichage de l'heure et des minutes (en chiffres) DT().dOpt({year: false, month: false, date: false, day: false, second: false, nat:false})
Affichage de la date sans le jour de la semaine DT().dOpt({day: false, hour: false, minute: false, second: false})
Affichage du jour et du mois seulement DT().dOpt({year: false, day: false, hour: false, minute: false, second: false})
Affichage de l'heure uniquement DT().dOpt({year: false, month: false, date: false, day: false, minute: false, second: false})
.dOpt({det: true}) Non affichage des déterminants de la date DT(new Date()).dOpt({det: false})
Affichage du déterminant DT(new Date()).dOpt({det: true})
.dOpt({rtime: false}) Affichage du temps relatif
(aujourd'hui)
DT(new Date()).dOpt({rtime: true})
Affichage du temps relatif
(il y a 4 jours)
var d = new Date(); d.setDate(d.getDate()-4); DT(d).dOpt({rtime: true});
Affichage du temps relatif
(dans 10 jours)
var d = new Date(); d.setDate(d.getDate()+10); DT(d).dOpt({rtime: true});

Nombre

Le module Number accepte en entrée une chaine de caractères ou une valeur numérique.

Création

Description Représentation syntaxique Réalisation en français Réalisation en anglais
Nombre entier NO(1)
Nombre entier (alternative) NO("1")
Nombre réel NO(1.4)
Nombre réel (alternative) NO("1.4")
Grand nombre entier NO(1208435739)
Nombre réel à plusieurs décimales NO(1.02785496)
Grand nombre NO(13856.5965047)

Options d'affichage

Option (avec valeur par défaut) Description Cas d'utilisation Réalisation en français Réalisation en anglais
.dOpt({mprecision: 2}) Obtenir un nombre entier NO(1.847584).dOpt({mprecision: 0})
Au maximum 4 décimales NO(1.847544).dOpt({mprecision: 4})
Au maximum 2 décimales NO(1.8).dOpt({mprecision: 2})
Au maximum 2 décimales NO(1.844957)
.dOpt({raw: false}) Affichage du nombre brut sans formattage NO("1 023,84").dOpt({raw: true})
Formattage du nombre NO(1.847544).dOpt({raw: false})

Accords en fonction du number (numérique)

Cas Option Cas d'utilisation en français Réalisation Cas d'utilisation en anglais Réalisation
Accord du nom avec un entier (zéro) NP(NO(0), N("avion")) NP(NO(0), N("bottle"))
avec un entier (un) NP(NO(1), N("avion")) NP(NO(1), N("bottle"))
avec un entier (deux) NP(NO(2), N("avion")) NP(NO(2), N("bottle"))
avec un réel (zéro) NP(NO(0.24), N("part")) NP(NO(0.24), N("litre"))
avec un réel (un) NP(NO(1.94), N("part")) NP(NO(1.94), N("litre"))
avec un réel (deux) NP(NO(2.01), N("part")) NP(NO(2.01), N("litre"))
Accord du nom et de l'adjectif avec un entier (zéro) NP(NO(0), N("avion"), AP(A("rouge"))) NP(NO(0),A("red"),N("bottle"))
avec un entier (deux) NP(NO(2), N("avion"), AP(A("rouge"))) NP(NO(2),A("red"),N("bottle"))
avec un réel (1) NP(NO(1.93), N("avion"), AP(A("rouge"))) NP(NO(1.93),A("red"),N("bottle"))
Utilisation des options d'affichage précision de 3 décimales NP(NO(2.847544).dOpt({mprecision: 3}), N("part")) NP(NO(2.847544).dOpt({mprecision: 3}), N("litre"))
précision de 0 décimales (arrondi) NP(NO(1.847544).dOpt({mprecision: 0}), AP(A("vieux")), N("personne")) NP(NO(1.847544).dOpt({mprecision: 0}), AP(A("old")), N("person"))