Dans la plupart des langages de programmation, on ne peut utiliser directement les accents et autres caractères non-anglosaxon. La solution est l'unicode, une sorte de code universel.

Par exemple pour afficher la chaine de caractères :
" là, ça dégénère !" il suffit de remplacer dans le code par la chaine de caractères suivante :
"l\u00E0, \u00E7a d\u00E9g\u00E9n\u00E8re !"
\u étant un caractère spécial permettant l'insertion d'un caractère unicode.

Un convertisseur est disponible ICI


Une liste complète des caractères unicodes, triés par unicode

triés par caractères

Pour plus d'informations sur l'Unicode et l'UTF-8:

En français:
http://sebsauvage.net/python/charsets_et_encoding.html (Lecture fortement recommandée !)
http://french.joelonsoftware.com/Articles/Unicode.html

En anglais:
http://www.joelonsoftware.com/articles/Unicode.html
http://www.tbray.org/ongoing/When/200x/2003/04/26/UTF
http://www.tbray.org/ongoing/When/200x/2003/04/06/Unicode

Lire la suite

[Java] Créer une applet qui accède au disque dur »

Habituellement, le système de sécurité des applets Java interdit totalement aux applets d'accéder aux ressources de la machine (disque dur, base de registre, etc.) ainsi qu'au réseau (l'applet ne peut communiquer qu'avec son serveur d'origine.)


Si vous voulez créer une applet qui outrepasse ces sécurités, il est nécessire:

- de créer une applet signée cryptographiquement
et
- que l'internaute autorise explicitement l'applet à accéder au système
(C'est une action volontaire de l'internaute qui ne peut être outrepassée.)



Une fois ces deux conditions réunies, vous pourrez lire/écrire sur le disque dur, lancer des programmes (Runtime.getRuntime().exec("...")), aller télécharger des choses (urlconnection) ou utiliser la commande eval().

Instructions

1) Compilez votre applet

comme d'habitude (créez un fichier .jar).

2) Générez votre clé

Votre clé cryptographique vous servira à signer toutes vos applets.

Tapez: keytool -genkey -alias votreNomdAlias
et entrez les informations nécessaires. N'oubliez pas le mot de passe que vous avez entré pour protéger cette clé.

Vous n'avez besoin de générer votre clé qu'une seule fois. Une fois votre clé créée, vous pouvez vous en servir pour signer autant d'applet que vous voulez.
(Notez que votre clé peut optionnellement avoir une date d'expiration.)

Note: Sous Windows, la clé est placée dans le profil utilisateur.
(\Documents and Settings\votrelogin\.keystore...)

Vous devez protéger à tout prix ce fichier de clés.
(Si vous vous le faites voler, quelqu'un pourra créer des applets malveillantes signées par vous !)

3) Signez votre applet avec votre clé

Tapez: jarsigner -verbose monapplet.jar votreNomdAlias

Entrez le mot de passe de votre clé.

Voilà, votre applet est signée.

4) Testez votre applet

Placez votre applet sur le serveur (c'est important), et testez la.

Vous verrez une fenêtre d'avertissemement pour la sécurité qui demande à l'internaute s'il autorise cette applet.

Exemple:
(Cette popup est générée par l'applet présente dans cette page )




Note: Le message de la popup signalant que la signature cryptographique est invalide est en réalité faux:
L'applet possède bien une signature cryptographique (la vôtre), mais cette signature n'a pas été validée par une autorité de certification (Thawte, VeriSign, etc.)

Or cette validation tierce (PKI) est payante.

Mais techniquement, elle n'est pas absolument pas nécessaire et ne réduit en rien la sécurité de fonctionnement de votre applet.

C'est juste que le fait de donner de l'argent à quelques PKI (dont les clés sont installées par défaut dans les navigateurs) vous permettra de vous débarasser de ce warning.

A vous de voir si payer pour ça en vaut le coup ou non.

Lire la suite

[Programmation] Polices de caractères pour programmeur »

Courrier: Un mauvais choix

La plupart des programmeurs utilisent la police de caractères Courrier pour travailler.

C'est un mauvais choix, car cette police est peu lisible.

• En taille 9, il est impossible de distinguer 0 (zéro) de O (lettre 'O') et 1 (un) de l (L minuscule) (Faites le test).
• Dès que cette police est en gras, elle est illisible.
• A cela s'ajoute l'empattement des caractères qui alourdit inutilement la lecture à l'écran.

Heureusement, il existe d'autres polices plus lisibles et qui permettent de réduire la fatigue visuelle.

De meilleures polices

Je vous recommande:
dejavu.sourceforge.net/wiki/index.php/Main_Page DejaVu Sans Mono (gratuite)
(ou bien la Bitstream Vera Sans Mono, qui est similaire. En fait, les polices DejaVu ne sont rien de moins que les Bitstream, mais avec un jeu de caractères plus étendu et, parait-il, plus "libre")
Cette police est anti-aliasée même en taille 8 (ce qui peut plaire ou non).

Dina (gratuite)
C'est une police bitmap disponible en tailles 8, 9 et 10, non-antialiasée.

La distinction 0/O 1/l est parfaitement claire avec ces polices, et les caractères restent lisibles même en gras.

Voici une comparaison de Courrier, DejaVuSansMono et Dina (cliquez pour agrandir):

Liens

Si ces deux polices ne vous suffisent pas, en voici d'autres:
www.dsg4.com
www.tobias-jung.de
websitetips.com
keithdevens.com/wiki/ProgrammerFonts keithdevens.com

Lire la suite

[Programmation] Critères de choix d'un langage/framework »

[Note de sebsauvage: Cet article est loin d'être complet ! à compléter, détailler et raffiner]

Voici quelques questions à vous poser pour bien choisir un langage, une plateforme de développement ou un framework pour un projet.

Il est impossible de dire de but en blanc que tel ou tel langage est le meilleur: Le meilleur choix sera très dépendant de vos besoins et contraintes. Les questions ci-dessous devraient vous guider.

Notez que chaque question peut ou non être importante ou pertinente pour votre projet. Tout ceci est très dépendant de votre projet.


Note: Cette liste n'est pas exhaustive.

Dans le document ci-dessous, le terme "langage" peut être remplacé par "framework" ou "plateforme de développement": les questions restent valides.

Nature

Est-ce un langage à typage fort, faible ?
à typage statique/dynamique ?
Compile-t-il en code natif ou tourne-t-il dans une machine virtuelle ?
Si natif, pour quels processeurs est-il disponible ?
Y'a-t-il une possibilité de temps d'exécution garanti ? Ou d'exécution sécurisée ?
Si machine virtuelle, sur quelles plateformes est disponible cette machine virtuelle ? Quelle est la maturité de la machine virtuelle sur chaque plateforme ?

Le langage permet-il une séparation nette données/code ?
Permet-il une séparation nette logique du programme/présentation ?
Supporte-t-il la programmation procédurale, assertionnelle, objet, évènementielle ? Est-ce important pour votre projet ?

Est-ce que ce langage/framework permet, favorise ou impose une approche n-tiers ? client/serveur ? centralisée ? déconnectée ? nomade ?
Est-ce important pour votre projet ?


Ce langage (et des librairies) peut-il se conformer à des standards ?
(XML, SOAP, HTTP, Rosetta.Net, ITIL, RFC et protocols divers...)

Portabilité

Ce langage est-t-il dépendant d'un système d'exploitation particulier ?
Sur combien de systèmes d'exploitation des compilateurs pour ce langage sont disponibles ? De combien de vendeurs différents ?
Est-ce que les API et librairies que vous utilisez seront disponibles dans d'autres systèmes d'exploitation ?

Est-ce que ce langage ou ses librairies permettent de faire abstraction du système d'exploitation ? Du matériel ? Des ressources (mémoire, disque...) ?

Stabilité

Depuis combien de temps existe ce langage ?
Est-il encore en beta ?
Des entreprises l'utilisent-elles ? Si oui, pour des tâches critiques ?
Avez-vous pu trouver sur internet des discussions critiques sur ce langage ? Que disent-elles ?

Pérennité

Depuis combien de temps existe ce langage ?
Ce langage est-il un standard (de fait, ISO, W3C, IETF...) ?
Si c'est un standard, y'a-t-il beaucoup d'implémentations différentes de ce standard ? Par combien de vendeurs différents ? Jusqu'à quel point ces implémentations respectent-elles le standard ?
Ce langage est-il propriétaire ou libre ?
Est-il ouvert ou fermé ?
Y'a-t-il des compilateurs de différents vendeurs pour ce même langage ?
Y-a-t'il une communauté forte autour de ce langage ?
Trouve-t-on des librairies, modules et exemples pour ce langage sur internet ? Dans quelle proportions ? Sont-elles majoritairement payantes ou gratuites ?

Le vendeur assure-t-il un support technique pour ce langage ?
Si oui, à quel tarif et quelles conditions ?
Quel est le cycle de vie de ce langage chez le vendeur ?
Jusqu'à quand sera-t-il supporté ?
L'enteprise assurant le support ou le vendeur lui-même sont-ils solides économiquement ?
Depuis combien de temps cette entreprise existe-elle ?
Quels sont ses clients utilisant le produit ?

Si le vendeur met la clé sous la porte, quelles conséquences pour vous et votre projet ?
Si le vendeur décide de ne plus supporter le produit, quelles conséquences pour vous et votre projet ?
Quels seraient les coûts de migration vers un autre langage ? Un autre serveur de base de données ? Un autre système d'exploitation ?

Vos données restent-elles accessible même si l'application/le langage/le framework/le vendeur vous lâche ?
Quels seraient les coûts de migration de vos données ?

Métier et maintenance

Trouve-t'on facilement des gens compétents sur ce langage ?
La syntaxe et les outils de ce langage permettent-ils une maintenance aisée ? (syntaxe claire, langage explicite...)

Les outils de génie logiciel sont-il disponible pour ce langage ?
(Modélisation, débuggers, IDE, RAD, code coverage, test unitaires automatisés, auto-documentation du code, analyse du code, build automatique, gestion de sources/versionning...)
Comment ce langage peut-il s'intégrer aux outils de génie logiciel existants dans le commerce ou déjà présents dans votre entreprise ?

Ce langage est-t-il bien documenté ? La documentation est-elle à jour ?
Des exemples sont-il disponible en nombre ?
Les API et librairies fournies avec ce langage sont-elles nombreuses ? Bien documentées ?

Le code et les données sont-elles accessible en dehors de l'IDE/RAD fourni avec le langage ?
Est-t-il possible de lancer la compilation et édition des liens en ligne de commande ?


Ce langage est-t-il déjà utilisé dans votre entreprise ?
Quels sont les retours des personnes l'ayant utilisé ? Que pouvez-vous apprendre d'eux (problèmes rencontrés, solutions, avis sur le support du vendeur, vie au jour le jour de la maintenance...)
Pouvez-vous capitaliser sur leur expérience ? (Utilisation des connaissances acquises par les autres, réutilisation des outils et librairies développés en interne, aide pour installation, documentations...)


Comment ce langage/framework pourra-t-il s'intégrer à l'infrastructure existante de votre entreprise ?
(Serveur de base de données, sites web, annuaires (Single SignOn, LDAP...), gestion de domaines, architecture réseau, règles de sécurité...)

Ouverture

Ce langage permet-il d'interagir avec d'autres langages ? (C, C++, Java...)
Quelle connectivité supporte ce langage ? (ftp, http, ssh...)
A quelles API ce langage permet-il d'accéder ? (Win32, SOAP, .Net...)
Ce langage est-il fortement lié à une API particulière ?
A quels types de bases de données ce langage permet-il de se connecter ? (Oracle, SQL Server, mySQL, ou génériques: ODBC, JDBC... ?)

Sécurité

Ce langage et ses librairies possède-t-il des fonctions intrinsèque de sécurité ?
Est-il vulnérable aux risques de buffer overflow ? Est-ce important pour votre projet ?
Aux risques de SQL injection ?
Aux risques de cross-site scripting ?
etc.
Les librairies fournies avec ce langage offrent-elles ces protections ?

License et droits

Que vous permet la license de ce langage ?
Y'a-t-il des risques juridique liés à ce langage ? (Qu'il soit propriétaire ou opensource).
Ou des risques juridiques liés à ses librairies ?
Avez-vous vérifié la license de chacun des librairies que vous utilisez ?
Quels droits de redistribution avez-vous sur ces librairies ?
Les licenses sont-elles compatibles entre elles ? Sont-elles compatible avec la license de votre propre logiciel ? Qu'imposent ces licenses sur votre license ou la distribution/vente de votre logiciel ?

Combien de poste développeur pouvez-vous équiper, et à quel prix ?
Devrez-vous repayer pour chaque serveur d'intégration et de production ?
Comment se calculent les coûts de license ? Par poste développeur installé, par nombre d'utilisateurs simultanés, par nombre de connexions réseau simultannées ?
Et en production: Par serveur installé, par utilisateur simultanés, par nombre total d'utilisateurs déclarés ?
Si le langage nécessite un runtime, quels sont les droits de distribution liés à ce runtime ?

Devrez-vous payer la license des librairies/runtimes nécessaire au langage/framework chaque fois que vous installera votre logiciel chez un nouveau client ?

Les différentes licenses imposent-elles des contraintes chez le client ?

Scalabilité

Qu'exige-t-il en matière de logiciel et matériel ? (Serveurs dédiés, système d'exploitation et serveur de base de données spécifiques ?)
Que vont vous coûter les licenses des logiciels, librairies et serveurs nécessaire pour faire fonctionner ce langage/framework ?

Quelle charge peut supporter un programme écrit dans ce langage ?
Que consomme-t-il comme ressources ? (mémoire, CPU, espace disque, débit réseau...)

Ce langage possède-t-il des goulots d'étranglement/limites/points faibles ? (lock globaux, nombre de connexions simultannées, quantité max de mémoire qu'il est capable d'utiliser...)

Ce langage/framework permettra-t-il à votre application d'être utilisée par 100, 1000 ou un million d'utilisateurs simultanément ?
Comment se comportera le langage/framework et votre application dans ce cas ?
Quelles sont les possibilités d'extension ? (clusters de machines, machines multi-processeurs ?) Le langage/framework supportera-t-il ces concepts ?

Lire la suite

[Programmation] Conversion RGB/HSL/CMYK... »

Il existe plusieurs manières de spécifier les couleurs (on dit qu'il existe plusieurs espaces de couleur).

En informatique, on utilise principalement RGB (rouge/vert/bleu), mais il est nettement moins intuitif que d'autres tels que HSL (Hue/Saturation/Lightness, Teinte/Saturation/Lumière).
Les espaces de couleur comme HSL sont également utile pour créer des nuances arc-en-ciel, ou bien pour assombrir ou éclaircir une image facilement.

Voici un site qui donne les algorithmes pour convertir entre ces différents espaces de couleur


Ces algorithmes sont faciles à programmer dans n'importe quel langage.
Exemple en Python

Traductions

• RGB (Red/Green/Blue) = RVB (Rouge/Vert/Bleu)
• CMYK (Cyan/Magenta/Yellow/Black) = CMJN (Cyan/Magenta/Jaune/Noir)
• HSL (Hue/Saturation/Luminosity) = TSL (Teinte/Saturation/Lumière)
• HSV (Hue/Saturation/Value) = TSV (Teinte/Saturation/Valeur)

Liens

Formules mathématiques, articles, outils:

• Article Wikipedia (français)
• Article Wikipedia (anglais)
• Pourpre.com (français)

Lire la suite

[Programmation] Les normes des webservices »

Les webservices étaient à l'origine une idée simple: Appeller une méthode sur un serveur distant.
L'appel et sa réponse sont écrits en XML, et les messages sont transporté par HTTP.

L'idée de départ a vu sa complexité augmenter dramatiquement, et les webservices sont désormais un ensemble très complexe de standards, protocoles et formats.

Voici un tableau qui tente de résumer tous les standards et protocoles qui tournent autour des webservices:



Vous pouvez télécharger ce document au format PDF
(PDF, 211 ko)

Liens

• (anglais) Article sur la complexité des webservices
• (anglais) Un article critique envers les webservices.
• XML-RPC tente de conserver l'aspect simple des webservices tout en permettant les appels distants.

Lire la suite

[Programmation] Conventions de passage de paramètres sous x86 »

Les conventions de passage de paramètres sous x86

Lorsqu'un programme est compilé pour une architecture x86, le passage de paramètres pour une fonction peut se faire de différentes manières: par la pile de droite à gauche, de gauche à droite, par les registres, ou encore par un savant mélange des deux. Le problème se pose aussi de savoir qui va nettoyer la pile utilisée par une fonction qui vient de se terminer: la fonction appelante ou la fonction appelée?

Vu ces possibilités, il a bien fallu déterminer des normes qui ont été choisies en fonction de contraintes d'optimisation, de compatibilité, ou encore à cause de l'usage de fonctions un peu exotiques.

Ayant croisé dernièrement le chemin d'un tutoriel plutôt bien fait sur ce sujet, je commence à me demander s'il est utile de faire un tuto sur le même thème alors que l'essentiel a déjà été dit. Ceci dit, je pense qu'il serait utile d'explorer ce qu'il se passe du côté de langages comme le C avec des compilateurs largement utilisés comme gcc et Microsoft Visual C++.

Bon, mais est-il encore utile de rééxpliquer toutes ces normes qui ont déjà été détaillées dans le lien cité plus haut? Borf, pourquoi pas tant qu'à faire... Je ne ferai que des explications sommaires et je montrerai ce que donne l'implémentation en assembleur d'une même fonction simple pour chaque norme et si vous voulez approfondir et avoir plus de détail, rendez vous sur le lien du dessus.

Notez que la syntaxe que j'utiliserai en assembleur sera celle utilisée avec l'assembleur nasm.

Introduction

On va partir d'une fonction simple, appelée depuis une fonction principale main:

int soustraction (int a, int b, int c)
{
    return a - b - c;
}

int main ( int argc, char **argv)
{
    int nb1, nb2, nb3, resultat;
    
    //....quelques bout de code, on donne des valeurs aux trois variables nb.
    
    resultat = soustraction (nb1, nb2, nb3);
    
    //...reste du code
}

Un compilateur a besoin de savoir quelle convention il faut utiliser pour le passage des paramètres.
Le plus pratique c'est de le définir dans l'en-tête de la fonction.
Celà permet au compilateur de savoir comment compiler cette fonction
et les autres fonctions qui l'appèlent. Pour gcc, Microsoft Visual C++, et Delphi, je noterai, pour chaque norme, comment la signaler dans l'en-tête d'une fonction.

Cdecl

Nettoyage de la pile par: Fonction appelante.

Passage de paramètres: De droite à gauche par la pile.

En-tête de la fonction "soustraction" avec gcc:

int __attribute__((cdecl)) soustraction (int a, int b, int c)

En-tête de la fonction "soustraction" avec Microsoft Visual C++:

int __cdecl soustraction (int a, int b, int c)

Cdecl est la convention normalement utilisée sous Linux. Ceci est dû aux fonctions possédant un nombre de paramètres variable comme printf. En effet, pour nettoyer la pile, la fonction appelée a besoin de connaître exactement la quantité de paramètres à vider lorsqu'elle fini son execution. Voir à ce sujet l'opérateur ret: l'opérande qui lui est associé doit être une constante. (A vérifier)

Exemple d'implémentation en assembleur avec notre fonction:

soustraction:
    push ebp
    mov  ebp, esp
    
    mov  eax, [ebp + 8] ; a
    sub  eax, [ebp + 12] ; a = a - b
    sub  eax, [ebp + 16] ; a = a -c
    
    leave
    ret
    
main:
    ....
   ;Passage des paramètres de droite à gauche
   ;(Premier paramètre au sommet de la pile)
    push dword [ebp - 12] ; param c
    push dword [ebp - 8]  ; param b
    push dword [ebp - 4]  ; param a
    
    call soustraction
    ;La fonction appelante nettoie elle-même la pile
    add  esp, 12
    .....

Stdcall

Nettoyage de la pile par: Fonction appelée.

Passage de paramètres: De droite à gauche.

En-tête de la fonction "soustraction" avec gcc:

int __attribute__((stdcall)) soustraction (int a, int b, int c)

En-tête de la fonction "soustraction" avec Microsoft Visual C++:

int __stdcall soustraction (int a, int b, int c)

Stdcall est la convention de passage de paramètres utilisée par l'api
de Windows. Il semble qu'elle permette d'économiser la quantité de code produit car la fonction appelante n'a plus besoin de nettoyer la pile après l'appel d'une fonction soumise à cette convention.

Exemple d'implémentation en assembleur avec notre fonction:

soustraction:
    push ebp
    mov  ebp, esp
    
    mov  eax, [ebp + 8] ;a
    sub  eax, [ebp + 12] ; a = a - b
    sub  eax, [ebp + 16] ; a = a -c
    
    leave
    ;La fonction appelée nettoie la pile (ici 12 octets car 3 entiers * 4 octets)
    ret  12
    
main:
    ....
    push dword [ebp - 12] ; param c
    push dword [ebp - 8]  ; param b
    push dword [ebp - 4]  ; param a
    
    call soustraction
    ;La fonction appelante n'a plus besoin de nettoyer la pile

Fastcall

Nettoyage de la pile par: Fonction appelée

Passage de paramètres: Le premier dans le registre ecx, le second dans le registre edx, les suivants, s'il y en a, sont passés dans la pile de droite à gauche comme sous Stdcall ou Cdecl.

En-tête de la fonction "soustraction" avec gcc:

int __attribute__((fastcall)) soustraction (int a, int b, int c)

En tête de la fonction "soustraction" avec Microsoft Visual C++:

int __fastcall soustraction (int a, int b, int c)

A noter que la convention "register" utilisée sous Delphi semble être un Fastcall mais implémenté d'une manière différente.

Exemple d'implémentation en assembleur avec notre fonction:

soustraction:
    push ebp
    mov  ebp, esp
    
    mov  eax, ecx  ; a (permier paramètre dans ecx)
    sub  eax, edx  ; a = a -b (second paramètre dans edx)
    sub  eax, [ebp + 8] ; a = a -c (les autres paramètres sont passés dans la pile)
    
    leave
    ;Pile nettoyée par la fonction appelée
    ret  4
    
main:
    ....
    mov  ecx, [ebp - 4]   ; param a
    mov  edx, [ebp - 8]  ; param b
    push dword [ebp - 12] ; param c
    
    call soustraction

Register

Nettoyage de la pile par: Fonction appelée.

Passage de paramètres: Premier paramètre dans le registre eax, le second dans le registre ecx, le troisième dans le registre edx, et les autres dans la pile (vérifier dans quel sens).

En-tête de la fonction "soustraction" avec gcc:

???

En-tête de la fonction "soustraction" avec Microsoft Visual C++:

???

Register semble être une implémentation différente de Fastcall sous Borland Delphi.

Exemple d'implémentation en assembleur avec notre fonction:

soustraction:
    push ebp
    mov  ebp, esp
    
    sub  eax, ecx
    sub  eax, edx
    
    leave
   ;Pile nettoyée par la fonction appelée. Mais en dessous de trois paramètres, il n'y a rien à nettoyer.
    ret
    
main:
    ....
    mov  eax, [ebp - 4]   ; a
    mov  ecx, [ebp - 8]  ; b
    mov  edx, [ebp - 12] ; c
    
    call soustraction

Pascal

Nettoyage de la pile par: Fonction appelée.

Passage de paramètres: De gauche à droite.

En-tête de la fonction "soustraction" avec gcc:

On dirait qu'il n'existe pas d'attribut sous gcc pour ça. Voir une magouille en dessous pour résoudre ça.

En-tête de la fonction "soustraction" avec Microsoft Visual C++:

//Sous d'anciennes versions (n'est plus supporté):
int __pascal soustraction (int a, int b, int c)

La convention utilisée avec le langage Pascal...
On dirait qu'il n'est pas/plus supporté sous gcc et Visual C++.
Ceci dit, on peut ruser. La convention pascal c'est comme un stdcall à l'envers. Donc pour utiliser notre fonction soustraction située dans une librairie compilée avec la convention pascal, il suffit de déclarer l'en-tête de cette fonction en stdcall et d'inverser les paramètres:
Exemple avec gcc:

int __attribute__((stdcall)) soustraction (int c, int b, int a)

Mais c'est à tester.

Exemple d'implémentation en assembleur avec notre fonction:

soustraction:
    push ebp
    mov  ebp, esp
    
    mov  eax, [ebp + 16]; a
    sub  eax, [ebp + 12]; a=a-b
    sub  eax, [ebp + 8]; a=a-c
    
    leave
   ; Nettoyé par la fonction appelée
    ret  12
    
main:
   ; Passage des paramètres de gauche à droite
    push dword [ebp - 4]; a
    push dword [ebp - 8] ; b
    push dword [ebp - 12]; c (dernier paramètre au sommet de la pile)
    
    call soustraction

Sources de ce document et liens

• Attributs de fonctions sous gcc 4.1.1 (en)
• Différents attributs de gcc (en)
• Article qui explique plus en détail toutes ces conventions. Il ya aussi plus de détails avec Deplhi. (fr)
• Conventions sous Microsoft Visual C++ (fr)
• x86 Calling Convention (en)
• Convention de passage de paramètres sous intel 64 bits (fr)

Lire la suite

La Licence GPL »

On parle énormément du logiciel libre, et de la licence GPL (General Public Licence). Voici cette fameuse licence :

Sur le site opensource.org, la GPL version 2
Sur le site gnu.org, la GPL version 3
(toute récente, et longtemps critiquée notamment par le père de linux...)
Pour ceux qui ne maitrise pas parfaitement l'anglais, voici une traduction (non officiel) de cette licence, disponible sur linux-france.org

Bonne lecture à tous :)

Lire la suite

Exporter à coup sûr du CSV »

Exporter des données au format CSV n'est pas si trivial qu'il n'y paraît. Dès que vos données contiennent des virgules ou des guillemets, tout semble partir en vrille.

Il y a une astuce.

Voici comment procéder pour exporter à coup sûr vos données en CSV:

• Doubler tout séparateur de chaîne trouvé dans la cellule ( ga"bu"zo ---> ga""bu""zo )
• Quoter systématiquement le contenu de chaque cellule ( toto ----> "toto" )
• Puis ajouter les cellules entre elles en séparant par une virgule. ( "toto","titi","tata" )
• Puis ajouter les lignes entre elles en séparant par \r\n

Et voilà !

Tout sera exporté correctement, même si vos cellules contiennent des virgules, des espaces, des guillemets ou même des retours à la ligne.

Exemple

Voici un fichier CSV complexe:

"colonne A","colonne B","colonne C"
"Il a dit ""coucou !"" hier.","Hé, Je contiens une virgule !","125"
"Attention:","Je contient
un retour à la ligne.","777"

Ce qui donne dans Excel:

Notes

• Note 1 : CSV signifie Comma-Separated Value. Le séparateur standard est donc la virgule (comma). Certaines versions d'Excel utilisent le point-virgule (semicolon) comme séparateur. Il faudra donc renommer le .csv en .txt, puis l'ouvrir avec Excel et préciser (dans le wizard d'importation) la virgule (comma) comme séparateur.
• Note 2 : Vous ne contrôlez pas la façon dont Excel va interpréter le contenu de chaque cellule. Par défaut, chaque cellule sera importée avec le type "General". Par exemple, tout numéro de téléphone comme "+33-123456" sera interprété comme une addition par Excel (qui calculera -123423). (Oui je sais, il est très con, Excel)
• Note 3 : Selon le paramétrage régional de Windows, le séparateur de nombre sera la virgule ou le point. C'est à vous de formater les nombres en fonction de la culture de vos utilisateurs. (Donc: Pensez à prévoir dans les pages web une option pour permettre à l'utilisateur de choisir le séparateur décimal.)
• Note 4 : Attention au signe égal en début de cellule: Excel essaiera d'interpréter ce qui suit dans la cellule comme une formule.

Exemple:

"","12"
"","34"
"Total:","=B1+B2"

Comme vous pouvez le voir, le format CSV pose divers problèmes (aucun contrôle sur la manière dont le contenu des cellules est interprété, aucun formattage (couleurs, format de nombre, etc..))
On peut palier à ces problèmes avec une autre astuce: Exportez des fichiers html (contenant des styles CSS spéciaux) et renommez ces fichiers html en .xls:
Excel saura l'ouvrir sans problème, et prendra en compte le format des cellules (type, couleur, etc.)
Voir (en anglais)

Lire la suite

Votre première application graphique avec Python et Glade »

Ce guide vous aidera à créer pas à pas votre première application graphique.

Nous allons utiliser le langage de programme Python et l'API graphique GTK, en utilisant le logiciel Glade pour créer facilement les interfaces graphiques.

C'est de la programmation évènementielle: Notre programme va passer son temps à attendre des évènements (tels qu'un clic de l'utilisateur sur un bouton), et réagira en conséquence en exécutant certaines parties du code.

Pourquoi Python+GTK+Glade ?

• Python est un langage propre, portable et facile à apprendre.
• GTK est une librairie graphique bien conçue, dont l'API est saine et portable.
• Glade permet de créer rapidement des interfaces graphiques à la souris, tout en séparant bien l'interface graphique du code du programme. La maintenance des programmes est simplifiée.

Installation des logiciels nécessaires

Sous Debian: sudo aptitude install python-glade2 glade-3

Création de l'interface graphique avec Glade

Nous allons créer une interface minimale: Un bouton et un label. Cliquer sur le bouton changera le texte du label.

Lancez Glade3 (Sous Ubuntu: Menu Applications > Programmation > Concepteur d'interface Glade)



et choisissez comme format du projet "libglade":

L'interface de Glade

Glade est composé de 4 zones:

• (A): Cette zone contient les widgets (éléments graphiques) disponibles prêts à être utilisés (boutons, cases à cocher, etc.)
• (B) est la fenêtre de travail, où vous placez widgets.
• (C) montre la hiérarchie des widgets.
• (D) vous permet de modifier les caractéristiques d'un widget.

Création de l'interface

Création de la fenêtre

Cliquez sur l'icône Windows (Fenêtre) puis cliquez dans la zone de travail. Cela va créer une fenêtre.



Comme vous pouvez le voir, Glade a automatiquement donné un nom à notre fenêtre: window1.
Vous pourrez le changer, mais pour le moment, gardons 'window1'



Notre fenêtre doit réagir quand on la ferme: On va donc dans l'onglet "Signals", et on clic pour ajouter l'évènement 'delete' dans la ligne 'delete-event'.
(delete-event correspond à une demande de fermeture de la fenêtre.)



Par défaut, les fenêtres sont créées invisibles.
Allez dans l'onglet "Common", et mettez l'attribut "Visible" à "Yes" afin que notre fenêtre soit visible.



Dans une fenêtre, il y a plusieurs manières d'arranger les éléments: côte à côte, l'un au dessus de l'autre, en grille...

Nous allons les mettre les uns au dessus des autres: Cliquez sur le conteneur vertical (Vertical Box) et cliquez dans la fenêtre: C'est maintenant ce conteneur qui sera en charge d'arranger les widgets dans la fenêtre.



Choisissez le nombre d'éléments à mettre: Mettez 2 (Nous allons mettre 1 bouton et 1 label.)

Ajout du bouton

Ajoutons un bouton: Cliquez sur le bouton et cliquez dans la fenêtre de travail pour ajouter ce bouton.



Changez le texte du bouton:



Enfin notre bouton devra réagir quand on clic dessus: Dans l'onglet "Signals", ajoutez "on_button1_clicked" dans l'évènement "clicked".

Ajout du label

De la même manière, ajoutez le label: cliquez sur l'outil "label" et cliquez dans la fenêtre de travail pour créer le label.



Changez le texte du label:

Résumé

Vous pouvez voir la hiérarchie des widgets que nous avons créés:



Nos deux widgets (bouton et label) sont dans le conteneur vertical vbox1 qui lui-même est contenu dans la fenêtre.

La plupart des interfaces graphiques sont conçues de cette manière: une hiérarchie de widgets imbriqués les uns dans les autres.

Enregistrer

Enregistrez le tout dans moninterface.glade:



Veillez à toujours enregistrer au format "libglade".

Création du programme

Le programme suivant va charger l'interface que nous venons de créer.

#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gtk.glade

class monprogramme:
    def __init__(self):
        self.widgets = gtk.glade.XML('moninterface.glade',"window1")
        events = { 'on_button1_clicked': self.monclic,
                   'delete': self.delete               }
        self.widgets.signal_autoconnect(events)

    def delete(self, source=None, event=None):
	gtk.main_quit()

    def monclic(self, source=None, event=None):
        self.widgets.get_widget('label1').set_text('Vous avez cliqué !')
        return True
       
if __name__ == '__main__':
    app = monprogramme()
    gtk.main()

Explications du programme

• (1) On charge le fichier glade (gtk.glade.XML('moninterface.glade'), et dans ce fichier on sélectionne notre fenêtre ('window1').
• (2) A chaque évènement défini dans l'interface, on attache (signal_autoconnect) une méthode qui sera appelée:
  • Sur l'évènement 'on_button1_clicked' (qu'on a placé sur le bouton), c'est la méthode self.monclic qui sera appellée. On modifie alors le label (...get_widget('label1').set_text(...))
  • Sur l'évènement 'delete' de la fenêtre, on appellera la méthode delete() qui réagira à la fermeture de la fenêtre en quittant (gtk.main_quit())
• (3) Enfin le main appelle notre classe.

Lancez le programme

Lancez le programme: python monprogramme.py

La fenêtre s'affiche:



Cliquez le bouton: Le label est modifié !



Bravo !

Vous avez réalisé votre première application graphique.

Aller plus loin

Vous pouvez maintenant ajouter tous les widgets que vous voulez, et les imbriquer de la manière dont vous voulez.

Libre à vous ensuite de définir des évènements sur certains de ces widgets, et de programmer le code qui va réagir à ces évènements (clics sur différents boutons, cases cochées, etc.)

Quelques astuces

Autoconnect... automatique

A chaque fois que vous ajoutez un évènement à votre interface, vous devez modifier le dictionnaire 'events' pour y ajouter le nom de l'évènement et le nom de votre méthode. C'est fastidieux.

On peut faire mieux: Ajoutez la méthode autoConnect ci-dessous, et vous n'avez plus qu'à nommer vos méthodes gtk_*.

Par exemple, il suffit de créer une méthode nommée gtk_on_button1_clicked pour qu'elle prenne automatiquement en compte l'évènement on_button1_clicked.

Notre programme devient:

#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gtk.glade

class monprogramme:
    def __init__(self):
        self.widgets = gtk.glade.XML('moninterface.glade',"window1")
        self.autoConnect()

    def autoConnect(self):
        eventHandlers = {}
        for (itemName,value) in self.__class__.__dict__.items(): 
            if callable(value) and itemName.startswith('gtk_'):  
                eventHandlers[itemName[4:]] = getattr(self,itemName) 
        self.widgets.signal_autoconnect(eventHandlers)

    def gtk_delete(self, source=None, event=None):
    	gtk.main_quit()

    def gtk_on_button1_clicked(self, source=None, event=None):
        self.widgets.get_widget('label1').set_text('Vous avez cliqué !')
        return True
       
if __name__ == '__main__':
    app = monprogramme()
    gtk.main()

Accéder plus facilement aux widgets

Ajoutez simplement cette méthode à votre classe:

    def __getitem__(self, key):
        return self.widgets.get_widget(key)

Et vos widgets seront plus facilement accessibles.

Par exemple au lieu de faire:

self.widgets.get_widget('label1').set_text('Vous avez cliqué !')

on fait simplement:

self['label1'].set_text('Vous avez cliqué !')

Liens

(partie à venir)

Lire la suite

Comment bien stocker et vérifier un mot de passe »

Si vous développez une application qui doit gérer les mots de passe, il est important de bien le faire, sous peine de risquer le piratage de votre système et la compromission des données de vos utilisateurs.

Il existe de bonnes pratiques pour stocker un mot de passe.

La bonne manière de stocker

Stockez le login et hash(login+salt+motdepasse)

Pseudo-code: passwordHash = MD5( login + "zo5pro$1pvkhj6*cz4a8ùtvb#ui4oeuio" + motdepasse )
Stockez login et passwordHash. Ne stockez pas motdepasse.

Pourquoi un hash ?

Il ne faut jamais stocker le mot de passe en clair.

Risque: Si quelqu'un s'introduit dans votre base de mots de passe, il pourrait les récupérer directement et les utiliser.

Protection: Le hash permet de calculer une empreinte du mot de passe. Comme l'algorithme n'est pas réversible, on ne peut pas retrouver immédiatement le mot de passe à partir du hash.
C'est pour cela qu'on utilise un hash cryptographique. Typiquement MD5, SHA-1 ou autre (SHA-256, SHA-512...)
Ne jamais utiliser de CRC ou CRC32.

Pourquoi un salt ?

Les rainbow-tables sont de grosses tables contenant des hash (MD5 et autres) précalculées.
Cela permet de retrouver très rapidement le mot de passe qui a donné un hash précis.

Risque: Si vous utilisez juste MD5(motdepasse), les rainbow-tables permettent de retrouver le mot de passe correspondant au MD5 en quelques minutes, voire quelques secondes.

Protection: En utilisant un salt, cela rend les rainbow-tables inutiles. Le salt est une valeur choisie au hasard. Sans un salt, un mot de passe comme "toto" sera immédiatement trouvé dans les rainbow tables. Avec un salt, non.
Votre salt peut être le même pour tous les utilisateurs, ou différent pour chaque utilisateur (il faut alors stocker le salt avec le login).

Pourquoi ajouter le login ?

Si vous stockez juste MD5(salt+motdepasse) ou MD5(motdepasse), cela veut dire que deux utilisateurs ayant le même mot de passe auront le même hash.

Risque: On peut repérer très facilement les utilisateurs ayant le même mot de passe. Si un utilisateur est compromis, cela permet d'accéder immédiatement à d'autres utilisateurs (qui ont peut-être des droits supérieurs).

Protection: En ajoutant le login avant de hasher, la MD5 résultante sera différente pour chaque utilisateur, même s'ils ont le même mot de passe.

Vérification

Lorsque vous recevez login et mot de passe, il vous suffit de refaire le même calcul:

• Rechercher dans votre base le hash correspondant à ce login
• Comparer la valeur avec hash(login+salt+motdepasse)
• Si les deux hash sont identiques, le mot de passe entré est correct.

Lire la suite

Utiliser Git sous Windows »

Au même titre que SVN ou CVS, GIT est un protocole de gestion de version sous licence libre. Toutefois, GIT est plus spécifique car il a été créé principalement pour le développement du noyau Linux. Aujourd'hui, il est tout à fait envisageable comme solution de gestion de version pour un projet logiciel.

Cependant, il y a un problème important avec ce gestionnaire: Git n'est pas officiellement supporté sous Windows.
Mais bien heureusement, il existe tout de même des clients Git tout à fait corrects sous Windows.

Installation de MsysGit

Parmi les solutions faciles à installer, il existe MsysGit.
Installez la dernière version.

En passant, sélectionnez "use Git Bash". Et laissez les autres options par défaut.

Test: Téléchargement de la dernière version "mainline" de Linux

Pour tester, nous allons télécharger la dernière version "mainline" du kernel Linux, c'est à dire la dernière version principale de développement du noyau. Pour cela, nous allons faire une copie d'arbre avec la commande git-clone.

Allez dans Démarrer > Programmes > Git > Git Bash.
Vous allez voir apparaître un shell.

Tapez-y les commandes suivantes:

mkdir mon_git
cd mon_git
git-clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git

Voilà, le temps d'un café, votre téléchargement devrait s'avérer concluant...

Lire la suite

Les guillemets, apostrophes et les chaînes »

Comment jouer avec les guillemets et les apostrophes dans les chaînes

1. Préambule

Vous vous posez parfois la question : "Pourquoi sans jouer avec les guillemets et apostrophes, ça coupe une chaîne?".
Une chaîne, c'est un texte simple ne dépassant pas, parfois, 256 caractères et ayant d'autres restrictions selon votre interpréteur.
C'est simple, dans tous les langages de programmation, vous devez ouvrir et fermer votre chaîne avec des guillemets. Faites-le tout le temps, de préférence, mais vous n'êtes pas obligé(e), si votre interpréteur comprend sans les guillemets, dans le cas d'une chaîne ne contenant pas d'espace.
Pourquoi les espaces ?
Parce que très souvent ça veut dire qu'on passe à autre chose, une autre fonction, etc ...

2. Éviter une coupure dans la chaîne

Si votre message est coupé, c'est sûrement que vous n'avez pas mis de guillemets ou des apostrophes, alors que votre message est coupé (par un espace en l'occurrence).
Il suffit de rajouter un guillemet ou une apostrophe aux deux extrémités de la chaîne.
Comme ceci (exemple en PHP) :

echo "<br><br>Bienvenue ...</b><br>";

J'aurais pu mettre :

echo '<br><br>Bienvenue ...</b><br>';

C'est pareil ... le résultat ne change pas.

3. Ajouter un guillemet dans la chaîne

Alors là, vous avez deux solutions, mais qui sont à adapter avec votre langage.

3.1 Avec l'apostrophe

Simple comme tout, encore un exemple en PHP, ensuite je vous explique :

echo "<iframe src='http://www.monsite.ty/moncode.html' height='500px' width='96%' style='align: center;'></iframe>";

Oui, je sais que vous avez deviné : On ouvre avec les guillemets et l'apostrophe est remplacée par les guillemets (ou reste telle quelle) au résultat.

3.2 Avec l'ASCII

On va changer un peu ... prenons du visual basic :

Dim exemple as String
exemple = "Je m' appelle : " & chr$(34) & "Zeurtchreinshrentizer" & chr$(34)

Donc là on utilise le code ASCII 34 : Le guillemet, qui sera interpreté ensuite.
Testez avec ça :

Dim exemple as String
exemple = "Je m' appelle : " & chr$(34) & "Zeurtchreinshrentizer" & chr$(34)
MsgBox exemple

J'ai donc fermé la chaîne pour implémenter le chr$().
Vous pouvez utiliser n'importe quels codes ASCII avec chr$().

3.3 Directement

3.3.1 Méthode recommandée

Le moyen le plus utilisé reste encore l'utilisation de l'antislash qui permet d'annuler l'interprétation d'un caractère, donc par exemple:

maVar = "Je m'appelle \"Zeurtchreinshrentizer\"";


Dans cet exemple, le "\" permet d'annuler l'interprétation du guillemet comme fin de string (chaine).

3.3.2 Seconde méthode

Certains compilateurs peuvent la gérer. ça reste rare, et peut mener à des erreurs. Néanmoins je vous la met quand même, puisque c'est un bon moyen de savoir les limites de son compilateur, alors vous testerez si vous voulez, mais généralement ça ne dérange pas un script dit Basic.
Donc il suffit de définir une variable telle que :

Guillemet = """

(à adapté avec votre langage)
Et avec ça, vous faites :

Guillemet = """
Message = "Voici le message : "+Guillemet+"Le message est là"+Guillemet

Cela revient bien sur à faire simplement :

Message = "Voici le message : """Le message est là"""

C'est donc là que vous pouvez vous rendre compte le pourquoi des conséquences, si ce n'est pas compatible.
Et voilà ...

Lire la suite

A quoi correspond un fichier avec l'extension .manifest? »

Problème

A quoi correspond l'extension .manifest?

Solution

Les fichiers .manifest contiennent des informations de style pour les programmes tournant sous les Windows de la génération NT (en gros, depuis XP).

Il contiennent en fait du XML. Pour l'ouvrir, il suffit d'avoir un navigateur supportant ce format (Firefox, Opera entre autres) ou un éditeur de texte comme le bloc-notes.


Merci à Groarh sur le forum pour cette astuce.

Lire la suite

Plugin EclEmma »

L'assurance de code se rapporte à une technique de technologie de programmation par lequel vous mesurer la qualité et la globalité de votre suite de tests en ayant des métriques simple comme le pourcentage des classes, des méthodes, des lignes, etc qui a été exécuté quand la suite de tests est exécutée.
Plusieurs outils permettent de faire l’assurance de code tel que Clover, corbertura ou Emma.
Dans ce qui suit on s’intéressera au plugin EclEmma.

Présentation du plugin EclEmma

EclEmma est un outil libre d'assurance de code Java pour l’IDE Eclipse, c’est un plugin qui est combiné à JUnit.
Les tests unitaires une fois lancés, l'outil va espionner le code appelé et va effectuer un marquage du code selon un code couleur. Par exemple, la couleur rouge est utilisée pour afficher le code que les tests unitaires ne couvrent pas. Il est donc possible de vérifier d'un coup d'oeil les bouts de code qui sont pris en charge ou pas.

Analyse du code source

Après l’exécution de l'application ou bien le test unitaire, l'information sur l'assurance de code est automatiquement disponible dans éclipse workbench :

• Vue d'ensemble d'assurance : l’assurance de code énumère des sommaires d'assurance pour des projets de java.

L’analyse assure des chiffres de couvrage de ligne, par méthode, par type, etc comme le montre les imprimes écran ci-dessous :

Couvrage de méthodes


Couvrage par ligne

• Source highlighting: Le résultat d'une session d'assurance est également directement visible dans le code source java à travers un marquage selon un code couleur. Les couleurs utilisés par défaut sont :
  • La couleur verte pour les lignes totalement couverte,
  • La couleur jaune pour afficher le code que les tests unitaires couvrent partiellement.
  • la couleur rouge est utilisée pour afficher le code que les tests unitaires ne couvrent pas

Ces couleurs sont paramétrées dans eclipse :
Menu windows->preferences->General->Editors->Text Editors ->Annotations,

• Dans les types d’annotations, on trouve “couvrage total”, “couvrage partiel” et “sans couvrage” avec le choix des couleurs correspondantes.

Les fonctionnalités d’Import/Export

EclEmma est principalement conçu pour des tests et analyse dans le workbench d'éclipse, mais il fournit aussi des fonctionnalités d’import/export.

• Assurance de code importé : Possibilité d’importation d’une session sous format *.ec
• Exportation de rapport d'assurance : Des données d'assurance peuvent être exporté sous le format de XML ou de HTML.

Export de rapport de couvrage

Lire la suite

Framework Mokito »

Mokito est un Framework de test des applications JAVA. Il permet de simuler des comportements complexes des objets, il facilite le développement des tests unitaires et la détection des erreurs .

Mockito est OpenSource et il est disponible sur l’adresse suivante : http://mockito.org/.


Mockito se base sur le principe d'un objet mock qui simule le comportement d'un autre objet .

L’implémentation des tests Mockito se fait en plusieurs étapes :

• Création du l’objet mock.
• Description du comportement attendu.
• Utilisation des mocks.
• Vérification que l’interaction avec les mocks est correcte.

Exemple :

public class ClasseA {
public ClasseA()
{
}
public void fonc1()
{
}
public void fonc2()
{
}
public int fonc3(int a, int b)
{
return a+b;
}
}


public class ClasseB {

ClasseA ca ;
public ClasseA getCa() 
{
return ca;
}

public void setCa(ClasseA ca) 
{
this.ca = ca;
}

public ClasseB()
{
ca =new ClasseA();
}

public void met1()
{
ca.fonc1();
ca.fonc1();
System.out.println(ca.fonc3(5, 6));
}
public void met2()
{
ca.fonc2();
}

}

• Test unitaire de la classe ClasseB :

import static org.mockito.Mockito.mock;
import org.mockito.Mockito;

public class Test 
{

public static void main(String[] args) 
{
ClasseA ca = mock(ClasseA.class);
ClasseB cb =new ClasseB();
cb.setCa(ca);
cb.met1();
Mockito.verify(ca, Mockito.times(2)).fonc1();
Mockito.verify(ca, Mockito.times(1)).fonc3( Mockito.anyInt(), Mockito.anyInt());
}

}

• Analyse du code :

ClasseA ca = mock(ClasseA.class);
=> On crée un objet ca, un mock de la classe ClasseA.

cb.setCa(ca);
=> On affecte l'objet ca à l'objet cb.

cb.met1();
=>On appelle l'objet cb avec la méthode met1().

Mockito.verify(ca, Mockito.times(2)).fonc1();
=> On vérifie que la méthode fonc1 du mock ca est appelé deux fois.

Mockito.verify(ca, Mockito.times(1)).fonc3( Mockito.anyInt(), Mockito.anyInt());
=> On vérifie que la méthode fonc3 du mock ca est appelé une seul fois par deux paramètres entier quelconque .

Lorsque la vérification échoue une exception est générée.

Exemple:

Mockito.verify(ca, Mockito.atLeast(1)).fonc2();
=> Cette ligne générer l'exception suivante:

Exception in thread "main" Wanted but not invoked:
classeA.fonc2();
-> at Test01.main(Test01.java:16)

==> Elle indique que la méthode fonc2() du mock ca n'est pas appelé .




On peut aussi modifier la résultat de retour d'une fonction .

System.out.println(" La résultat de ca.fonc(3,3) est "+ca.fonc3(3, 3));
Mockito.when(ca.fonc3( Mockito.anyInt(), Mockito.anyInt())).thenReturn(Integer.valueOf(5));
System.out.println(" La résultat de ca.fonc(3,3) est "+ca.fonc3(3, 3));

Analyse du code:

Mockito.when(ca.fonc3( Mockito.anyInt(), Mockito.anyInt())). thenReturn(Integer.valueOf(5));

=> La valeur de retour de la fonction fonc3 du mock ca était 0.
On la force à 5.

Cette fonctionnalité est surtout utile lorsqu’on a une fonction qui contient plusieurs traitements (des conditions, des boucles whiles,…)et on veut vérifier le comportement de toute la fonction. On a besoin donc de configurer les mocks utilisés dans cette fonction pour qu'elle passe tous ces traitements et conditions.

Lire la suite

Installation de USVN »

USVN est un serveur subversion en mode web très simple à installer et à administrer via une interface conviviale et très ergonomique.

Pré-requis

L'installation de USVN requiert la présence de :

• PHP 5 (5.1.2 <= ver < 5.3)
• apache2
• mod_dav enable (dans Apache httpd.conf - décommenter "LoadModule dav_module modules/mod_dav.so")
• mod_dav_fs enable (dans Apache httpd.conf - décommenter "LoadModule dav_fs_module modules/mod_dav_fs.so")
• mod_rewrite enable (dans Apache httpd.conf - décommenter "LoadModule rewrite_module modules/mod_rewrite.so")
• ajout de la configuration AllowOverride
• Subversion - ajouter les modules suivant au modules d'Apache
  • mod_authz_svn enable (ajouter dans httpd.conf "LoadModule authz_svn_module modules/mod_authz_svn.so")
  • mod_dav_svn enable (ajouter dans httpd.conf "LoadModule dav_svn_module modules/mod_dav_svn.so")

Exemple de configuration d'Apache

# Configuration d'access à usvn
Alias /usvn /chemin/vers/usvn/public
<Directory "/chemin/vers/usvn/public">
    Options +SymLinksIfOwnerMatch
    AllowOverride All
    Order allow,deny
    Allow from all
</Directory>

Installation de USVN

Une fois que les pré-requis installé et l'application configuré comme indiqué dans le serveur web, il faut y accéder via le navigateur web.
Il faut suivre les instruction d'installation étape par étape pour configurer l'installation.
A la fin de l'installation, un bloc de configuration est fourni pour être ajouté au fichier de configuration d'Apache httpd.conf. Un fois ce bloc ajouté, l'application est installé.

Lire la suite

Ajax : Communication entre un script Perl et JavaScript »

Pour faire communiquer du Perl et du Javascript d'une manière élégante et interactive, à savoir, pouvoir recharger une partie d'une page html à défaut de la page entière, on va mettre en place la technologie Ajax en utilisant l'objet Javascript XMLHttprequest.

L'objet XMLHttpRequest

Cet objet Javascript permet de mettre en place AJAX et permet donc de faire communiquer dynamiquement un client et un serveur. On va par exemple utiliser cette technique si on veut récupérer dans un script Javascript des données d'une base de données placées sur le serveur.

Nous ne détaillerons pas cet objet car la documentation abonde sur Internet, nous allons plutôt réaliser un exemple concret avec une page html, un script Javascript et un script Perl. Notre document html intégrera un champ texte, dont le contenu sera envoyé au script Perl pour être modifié, puis renvoyé pour être inséré par le script en javascript dans la page html dynamiquement. A vous de modifier cette base pour en faire quelque chose d'intéressant !

Pour approfondir l'objet XMLHttpRequest, voici quelques liens :
- AJAX sur Wikipédia
- Des exemples concrets sur XMLHttpRequest
- L'objet XMLHttpRequest sur commentcamarche.net

L'exemple

Mise en place

L'exemple est réalisé pour le répertoire par défaut d'apache : /var/www . Penser à installer le module CGI.pm et à donner les droits d'exécution au script perl. N'oubliez pas de spécifier à apache que vous avez des cgi à exécuter avec ce genre de directive :

      
ScriptAlias /cgi-bin/ /var/www/cgi-bin/     
< Directory "/var/www/cgi-bin/" >     
 AllowOverride None     
 Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch     
 AddHandler cgi-script cgi pl     
 Order allow,deny     
 Allow from all     
< /Directory >     

La page HTML

<  !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"     
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"  >     
< html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en" >     

< head >     
 < title >Comment lancer un script Perl depuis JavaScript< /title >     
 < meta http-equiv="content-type" content="text/html;charset=utf-8" / >     
 < meta name="generator" content="Geany 0.14" / >     
 < script type="text/javascript" src="/CallServer.js" >< /script >     
< /head >     
< body >     
 < input id="yourtext" type="text" size="50" value="Allez y écrivez un texte et appuyez sur le bouton..." / >     
 < input id="callPerl" type="submit" value="Vas-y script Perl !" onclick="call_server.launch();" / >     
 < br / >     
 < br / >     
 < div id="resultat" >< /div >     
< /body >     
< /html >

Le script Javascript

//Constructeur de la "classe" Callserver    

function CallServer ()     
{     
 this.xhr_object;     
 this.server_response;     
      
 this.createXMLHTTPRequest = createXMLHTTPRequest;     
 this.sendDataToServer = sendDataToServer;     
 this.displayAnswer = displayAnswer;     
 this.launch = launch;     
}     


//On crée l'objet XMLHttpRequest     

function createXMLHTTPRequest()     
{     
 this.xhr_object = null;     
      
 if(window.XMLHttpRequest)     
 {     
    this.xhr_object = new XMLHttpRequest();     
 }     
 else if(window.ActiveXObject)      
 {     
    this.xhr_object = new ActiveXObject("Microsoft.XMLHTTP");     
 }     
 else      
 {     
    alert("Your browser doesn't provide XMLHttprequest functionality");     
    return;     
 }     
}     

//On envoit des données au serveur et on reçoit la réponse en mode synchrone dans this.server_response     

function sendDataToServer (data_to_send)     
{     
 var xhr_object = this.xhr_object;     
      
 xhr_object.open("POST", "/cgi-bin/Server.pl", false);     

 xhr_object.setRequestHeader("Content-type", "application/x-www-form-urlencoded");     
      
 xhr_object.send(data_to_send);     
      
 if(xhr_object.readyState == 4)     
 {      
  this.server_response = xhr_object.responseText;     
 }     
}     

//On injecte la réponse du serveur dans la div nommée resultat    

function displayAnswer ()     
{      
 document.getElementById("resultat").innerHTML = this.server_response;     
}     

//Exécution du Javascript  

function launch ()     
{     
 this.sendDataToServer(document.getElementById("yourtext").value);     
      
 this.displayAnswer();     
}     

//Création de l'objet call_server    

var call_server = new CallServer();     
call_server.createXMLHTTPRequest();

Le script Perl

#!/usr/bin/perl     

use strict;     
use warnings;     
use CGI;     

#On crée notre objet qui initialise le CGI et crée une couche d'abstraction envoi/réception pour communiquer avec notre client    

package Ajax;     

#Constructeur de la classe Ajax    

sub new     
{     
 my($classe) = shift;     
      
 my $self = {};     

 bless($self, $classe);     
      
 $self->{CGI} = CGI->new();     
      
 print $self->{CGI}->header('text/html;charset=UTF-8;q=0.9,*/*;q=0.8');     
      
 return $self;     
}     

#Méthode qui nous permet de recevoir les données du client et les renvoit sous forme de tableau     

sub getDataFromClient     
{     
 my ($self) = shift;     
      
 return $self->{CGI}->param("keywords");     
}     

#Méthode qui envoit des données au client     

sub sendResultToClient     
{     
 my ($self, $data_to_send) = @_;     
      
 print $data_to_send;     
}     

#Notre incroyable méthode qui transforme du texte     

sub change     
{     
 my ($self) = shift;     
      
 my $result = "Votre texte transformé : ";     
      
 my @texte = $self->getDataFromClient();     
      
 foreach(@texte)     
 {     
  $result = $result.$_."Rajout inutile juste pour montrer que ça fonctionne";     
 }     
      
 $self->sendResultToClient($result);     
}     

1;     

## Début du script perl ##     

my $ajax = Ajax->new();     

$ajax->change();