Fondation REBOL

Aller au contenu | Aller au menu | Aller à la recherche

jeudi 21 juin 2007

Cheyenne et SSL (1/2)


Dans la série sur Cheyenne, et avec les versions indiquées dans les précédents billets,
il est possible d'utiliser le SSL avec la solution suivante décrite sur Altme :

1- récupérer l'exécutable stunnel.exe sur http://www.stunnel.org/ : il s'agit pour moi de la version 4.20 (stunnel-4.20-installer.exe).

2 - installer le logiciel

3 - Après l'installation, aller dans Démarrer > Programmes > Stunnel et éditer le fichier de conf



4 - Dans le fichier de configuration, décommenter les lignes relatives à https (en incluant l'en-tête https !!)

-----------------

-----------------

5 - Installer le service et lancer le ensuite.

6 - Lancer Cheyenne

7 - Ouvrez votre navigateur préféré et taper l'URL : https://localhost/

8 - Après les dialogues de confirmation sur le certificat utilisé, voici ce que vous aurez :



mardi 19 juin 2007

Cheyenne et Perl


Dans la série sur Cheyenne, et avec la version r0916 de Cheyenne (qui gère aussi le PHP via Fastcgi), il est possible d'utiliser des scripts en Perl.

Il suffit pour cela d'avoir :
  • Perl installé sur votre machine : par exemple dans C:\Perl\bin (cf le site d'ActiveState)
  • de faire pointer le sheban de vos scripts Perl (*.pl) vers l'exécutable Perl: #!C:\Perl\bin\perl.exe -wT
  • d'avoir vos scripts quelque part sous le root-dir (%www) de Cheyenne, comme dans l'exemple fourni avec la release 0916.

Et c'est tout !

Nul doute que Cheyenne permettra aussi d'instancier des scripts en Python, Ruby, etc...
Que ce soit pour conserver un existant ou pour jongler entre différents languages, voilà encore une découverte sympa !

===Philippe

Cheyenne et PHP

Dockimbel a mis en ligne une nouvelle version de Cheyenne.

Il est possible de la télécharger ici : cheyenne-r0914

Il est possible d'utiliser avec cette version Php, ce qui peut être très intéressant pour la reprise de sites existants ou mixer du code rebol avec du PHP.

Comment faire ?

1 - Tout d'abord dézipper la nouvelle version de cheyenne dans un répertoire sur votre PC.

2 - Dans httpd.cfg, le fichier de configuration de cheyenne, indiquer le chemin complet vers la racine du site, par exemple chez moi :

root-dir %/F/PERSO/REBOL/Projects/Cheyenne/cheyenne-r0914/Cheyenne/www/

3 - Récupérer une version de php (sur php.net, j'ai récupéré la dernière version (5.2.3) en archive zip.)

4 - Dézipper cette version dans l'arborescence de Cheyenne.

5 - Paramétrer le fichier php.ini de sorte que la variable doc-root soit identique à la variable root-dir (ou dans une sous-arborescence) :

doc_root = "F:\PERSO\REBOL\Projects\Cheyenne\cheyenne-r0914\Cheyenne\www"

6 - Ouvrir une fenêtre DOS et tapez la commande suivante (à adapter selon votre arborescence) :

php-cgi.exe -B 9999

Cette commande spécifie au moteur php d'écouter sur le port 9999 (port par défaut du mode FastCGI, cf code du module mod-fastcgi).

7 - Dockimbel a prévu dans sa livraison un fichier test.php (contenant juste l'appel à phpinfo())
Donc, lancer cheyenne et ouvrir votre navigateur préféré en appelant l'URL :

http://localhost/test.php

8 - Si tout va bien, vous devriez voir apparaître ceci :

phpinfo sous cheyenne

Sympa, non ?

===Philippe

mercredi 09 mai 2007

DevCon2007 : c'est maintenant !

La prochaine conférence des développeurs Rebol se déroulera à Paris les 10 et 11 mai 2007.

DevCon2007

Adresse du site : http://devcon2007.rebdocproj.net

jeudi 03 mai 2007

Eclipse et Rebol 2/2

Voici la suite ...
J'avais trouvé en 2005 un plugin permettant sous Eclipse de lire (avec coloration syntaxique) les fichiers REBOL.
Le plugin en question a depuis évolué, mais il existe ici : Color Editor

L'installation du plugin est simplissime. Il suffit de placer l'archive jar dans le répertoire plugin d'Eclipse.
A noter qu'il y a des préférences dédiées (couleurs, etc) pour cet éditeur, dans les préférences d'Eclipse.
Et voici à quoi ressemble un fichier REBOL avec Color Editor :



Il est possible pour les audacieux d'améliorer ce plugin.

===Philippe

Eclipse et Rebol 1/2

Voici le premier billet consacré à Eclipse et REBOL.

Je ne vais pas présenter Eclipse, juste signaler que j'ai utilisé le SDK 3.2 pour ces billets. L'idée est d'utiliser Eclipse comme environnement de développement (et en particulier les fonctions d'édition) pour notre language préféré.

Le document ci-joint (format Word) explique comment utiliser Eclipse (et les External Tools) pour lancer une VM REBOL, ici avec View. Bonne lecture !

Configurer_Eclipse_avec_une_VM_REBOL.doc

===Philippe
PS. Il s'avère que le document semble corrompu (plus d'images).
Voici les étapes telles que présentées pour Eclipse 3.2 :
Affichage du la configration External Tools :
Sous Eclipse, aller dans le menu RUN > External Tools > External Tools
Sélectionner l'item Program et cliquer sur le bouton New en bas à gauche.
Pour Eclipse 3.2, il faut utiliser le bouton New en haut à gauche ou double-cliquer sur l’icône « Program »
Dans la fenêtre qui s'affiche, fournir un nom "rebolview" (par exemple) pour identifier la VM Rebol.
Indiquer dans le champ Location, le chemin vers la VM Rebol (en utilisant le bouton Browse File System qui permet de se déplacer dans l'arborescence de votre système.)
Dans le champ Directory , indiquer : ${container_loc} ou le chemin dans le workspace qui est le chemin vers le répertoire du script
Dans le champ Arguments, écrire : -s ${resource_loc}  (le –s désactive la sécurité de la VM Rebol)
Il peut être nécessaire d’avoir des apostrophes autour de la variable ${resource_loc} si le chemin vers le fichier contient des blancs (et une erreur Rebol do/args se produirait).
Cliquer sur l'onglet Common puis dans cet onglet sur la case à cocher Display in favorites Menus
Valider les opérations en cliquant sur le bouton Apply  , puis sur le bouton Close (sous Eclipse 3.2)
Lorsque vous choisirez un script REBOL, le menu Run > External Tools possédera un nouvel item "RebolView", avec lequel vous pourrez exécuter le script.


jeudi 22 février 2007

La fonction launch


En étudiant un vieux script de Carl, j'ai découvert la ligne suivante :
launch/secure-cmd file

J'avais déjà vu la fonction launch dans des scripts, mais c'est le raffinement /secure-cmd qui m'a interpellé.
Vite, une recherche avec l'aide en ligne :
>>? launch
USAGE:
    LAUNCH value /reboot /uninstall /link url /quit /secure-cmd /as-is /install

DESCRIPTION:
     Launches a new REBOL interpreter process.
     LAUNCH is a native value.

ARGUMENTS:
     value -- The command-line arguments (Type: any-string)

REFINEMENTS:
     /reboot -- Reserved
     /uninstall -- Restart with uninstall option
     /link -- Reserved
         url -- (Type: any)
     /quit -- Launch first, then quit
     /secure-cmd -- Reserved
     /as-is -- No quotes around command line argument
     /install -- Restart with install option


Je vous laisse essayer les différentes options, qui sont assez parlantes.
Dans le cas de /secure-cmd, une nouvelle console est lancée et est dissociable de la première.

Illustration :

Ouvrez une console REBOL et tapez-y :
launch/secure-cmd ""
Une nouvelle console s'est en principe superposée à la première.
Fermez la première, le deuxième reste.
Pratique pour lancer des scripts dans un environnement à part de celui en cours.

===Philippe

vendredi 16 février 2007

Initialisations multiples

Les reboleurs savent qu'il est pratique de réaliser des initialisations multiples de variables ainsi :
>>a: b: c: d: none     ; plusieurs variables, une ligne
>>probe a
none
mais il est aussi possible d'initialiser des mots globaux ainsi :
>> set 'pr set 'pr1 set 'pr2 :print
>> pr "hello"
hello
>> pr2 "Salut"
Salut
>> pr1 "Cà va ?"
Cà va ?
La concision du langage REBOL m'étonne toujours.

===Philippe

Extract

Extract est une fonction bien pratique pour - surprise - extraire des données de séries.
Soit une liste dont on veut extraire un élément sur deux :

liste: ["A" 1 "B" 2 "C" 3 "D" 4 "E" 5 "F" 6]
extract liste 2
>>["A" "B" "C" "D" "E" "F"]

Maintenant, comment faire pour extraire un élément sur deux, mais à partir du deuxième élément ?
Il suffit de faire appel au raffinement /index de la fonction extract :
extract/index liste 2 2      ; prend les éléments à partir du second et par pas de 2. 
>>[1 2 3 4 5 6]
extract/index liste 3 3      ; prend les éléments à partir du troisième et par pas de 3. 
>>["B" 3 "E" 6]

Voilà, c'est un exemple simple, mais à explorer sur des listes plus sophistiquées.
===Philippe

mercredi 07 février 2007

Comment créer un exécutable en Rebol ? 4/4

Pour terminer ce survol:

XPackerX :


Il est possible de trouver XPackerX ici


Aprés récupération du soft et installation, le répertoire se présente ainsi :

Le fichier d'aide permet d'avoir aussi des illustrations du fonctionnement de XpackerX.
L'arborescence du répertoire sample montre qu'il est possible d'utiliser d'autres langages que REBOL : perl et python sont aussi au menu.
Dans le sous-répertoire dédié à REBOL, plusieurs exemples sont fournis selon la version de VM choisie.

Comment cela marche-t-il ?

Il faut lancer l'exécutable XpackerX en double-cliquant dessus.



XPackerX a tout d'abord l'allure d'un petit éditeur de texte, permettant de gérer par défaut des fichiers XML.
Voir par exemple le menu "Tools" et son sous-menu "Preferences".
L'interface présente plusieurs boutons.
Le menu ou bien le bouton "New" permet d'afficher un template de fichier XML contenant les balises essentielles à la création d'un fichier exécutable auto-extractible. C'est le principe d'XpackerX : il va encapsuler l'ensemble de vos fichiers, lesquels seront décompressés dans un répertoire puis exécutés, et enfin effacés à l'issue de l'exécution.
Pratiquement tout est paramétrable : le répertoire d'exécution, les fichiers et leurs arborescences d'origine ou cible, l'icône. Il suffit pour cela de remplir correctement le fichier XML proposé.




L'intérêt est bien sûr, le fichier rempli, de pouvoir rejouer plusieurs fois une encapsulation. Une fois la bonne configuration établie, le lancement de l'encapsulation se fait en cliquant sur l'icône représentant un "point d'exclamation rouge". Un message d'alerte indique la bonne fin ou non de l'opération.



Dans le cas de notre fichier hello.r, avec une VM View, l'encapsulation est très rapide, et le résultat est un petit fichier compressé (72% de la taille originale script+VM).
L'exécution du fichier est elle aussi rapide. Par défaut, deux petits messages s'affichent pour signaler la décompression des fichiers avant exécution, puis leur suppression après. Il est possible de supprimer ces affichages en mettant dans le fichier XML la balise showextractioninfo à false.
La liste suivante, une traduction de ce qui se trouve dans la doc, montre les élèments possibles du paramétrage.

<xpackerxdefinition>
(obligatoire)
Le noeud racine. Doit exister.
<general>(obligatoire)
Les paramétrages généraux de l'application à créer.
<appname>(obligatoire)
Le nom de l'application (ex. Mon Application 1.1)
</appname>
<exepath>(obligatoire)
L'arborescence où l'application sera créée. Un chemin absolu, ou relatif
au fichier XML.  (ex. c:\projects\test\output.exe ou un
chemin local output.exe)
</exepath>
<iconpath>(optionnel)
Le chemin vers le fichier pour l'icône de l'exécutable.
The path to the icon for the executable.Un chemin absolu, ou relatif
au fichier XML. (ex. c:\projects\test\mon-icone.ico ou un
chemin local comme mon-icone.ic)
</iconpath>
<showextractioninfo>(optionnel)
Cette directive permet (true) un bref affichage d'informations
lors de l'extraction et de la suppression des fichiers temporaires.
Si cette valeur est à False, il est souhaité (mais pas obligatoire)
qu'un petit mot de remerciement pour XpackerX soit inclus dans votre
exécutable ou sa documentation.
Valeurs possibles : True ou False. Par défaut: True
</showextractioninfo>
<searchpath> (optionnel)
Le nom de la VM requise.
(ex. rebol.exe)
</searchpath>
<searchappname> (optionnel)
Le nom usuel de la VM utilisée. Si le fichier spécifié dans
searchpath ne peut être trouvé, alors ce nom usuel est utilisé
dans l'alerte émise vers l'utilisateur final.
(ex. Rebol)
</searchappname>


</general>

<files>(obligatoire)
Ici on a la liste des fichiers qui doivent être inclus dans l'exécutable (HostExe).
Il peut y avoir autant de fichiers que nécessaire.
<file>(un ou plusieurs sont requis)
La définition du fichier à inclure
<source>(obligatoire)
Le chemin vers le fichier à inclure. Peut être absolu, ou relatif
au fichier XML
(ex. c:\projects\test\folder\input1.exe ou un fichier,
relativement au fichier XML folder\input1.exe)
</source>
<destination>(obligatoire)
Le chemin sous $TMPRUN où le fichier doit être extrait.
$TMPRUN est ajouté devant ce chemin, ce qui nécessite
que celui DOIT être relatif. (ex. folder\input1.exe).
Un chemin absolu est incorrect (ex. C:\folder\file n'est
PAS permis)
</destination>
</file>
</files>

<onrun>(obligatoire)
La ligne de commande complète à jouer lorsque les fichiers ont été
extraits. Celle-ci peut comprendre n'importe laquelle des variables pré-définies
$TMPRUN, $WINDIR, $PROGRAMDIR, $WINSYSDIR
(e.g. $TMPRUN
ebol.exe -qs $TMPRUN\un-script.r)
</onrun>


XPackerX permet donc de créer un exécutable à partir de diverses VM, dont notre préférée, l'outil est simple, assez paramétrable, et son usage assez intuitif.
L'encapsulation puis l'usage d'un fichier exécutable est assez rapide en fonctionnement.
XPackerX est donc une bonne alternative à Encap, seul défaut : ne fonctionner que sous Win32.

Conclusion :

Voilà en quelques articles un bref survol de divers outils pour créer un exécutable avec REBOL. A vous de faire votre choix et de plonger dans les arcanes de ces outils.

jeudi 01 février 2007

Comment créer un exécutable en Rebol ? 3/4

Ici voyons le cas de Grebox et de Payload :

Grebox :


Historiquement créé par 'Spag pour Linux, le code a été porté par Shadwolf sur Win32.
Shadwolf a aussi ajouté un script Rebol pour avoir une interface visuelle.
Il est possible de trouver l'archive Grebox ici


Aprés récupération de l'archive et décompactage, le répertoire se présente ainsi :

Il y a donc plusieurs fichiers et répertoires, mais intéressons nous au fichier launch-grebox.bat.
Il permet de lancer l'interface Grebox (celle-ci s'appuie sur une version 1.2 de Rebol/view livrée dans l'archive).

L'interface de Grebox permet de choisir un nom de projet, le fichier source, le type d'exécutable REBOL, et quelques autres caractèristiques comme la compression des ressources.


La compilation est lancée par le bouton suivant :

L'exécutable Hello.exe (si Hello est le nom du projet) sera créé dans le répertoire out.
Appliqué à notre fichier hello.r, la compilation met une dizaine de secondes à se faire, avec des fenêtres d'alerte pour indiquer la progression de la compilation.
En mode compressé, le fichier résultant fait 251 Ko, et 531 Ko sinon, avec une VM REBOL/View 1.2.
A l'exécution, 3 à 5 secondes se passent avant l'affichage du "HELLO", et la décompression des fichiers temporaires.


Grebox permet donc de créer un programme exécutable avec une VM Rebol dédiée, de compresser, d'ajouter une icône. Pour autant le temps de compilation (avec ou sans compression) est relativement lent.
(Est-ce dû à l'usage de REBOL/View 1.2 ?).
L'ensemble mériterait une meilleure présentation.

Payload :


Payload est un outil produit par Olivier Auverlot (auteur du 1er livre français sur REBOL - Ed. Eyrolles), et François Jouen, l'une des figures historiques des reboleurs francophones.


Payload existe en version Linux, MacOSX et Windows. Vous pouvez récuperer les archives, là :


Il est possible de rajouter aussi une couche graphique avec gpl.r, un script REBOL réalisé par François Jouen.
A noter aussi, que sur mon PC sous XP SP2, une alerte de sécurité s'est déclenchée lors du dézippage de l'archive Windows.

Voici à quoi ressemble le contenu du répertoire créé :


Il est possible avec gpl, d'avoir une interface graphique pour saisir toutes les informations nécessaires à la création de l'exécutable.



Sinon, en ligne de commande, Payload réclame trois arguments :
  • le nom et chemin du script REBOL
  • celui de la VM REBOL
  • et le nom de l'exécutable.


Il est possible que l'alerte de sécurité de REBOL se déclenche pour la construction de l'exécutable.



L'exécutable créé (ici avec REBOL/Core) présente une icône spécifique (une locomotive). Les différents fichiers sont aussi compressés, ce qui va induire une petite lenteur lors de l'exécution.
La figure suivante montre d'ailleurs, lors de l'exécution, le fichier temporaire décompressé.


En résumé :

Le fonctionnement de Payload et le contenu de l'archive sont très simples. Il n'est pas possible cependant d'avoir une icône associée au fichier créé.
Pour cela, l'usage d'un gestionnaire de ressources est nécessaire.
Voilà pour le petit tour à propos de Grebox et Payload.


Pour conclure cette étude, un dernier outil : XPackerX.

jeudi 21 décembre 2006

Comment créer un exécutable en Rebol ? 2/4

Une autre possiblité : en utilisant NSIS

NSIS est un software permettant de créer un installateur.
Cette technique a été développée par Gregg pour Namexif (www.digicamsoft.com)
Voir le lien : http://nsis.sourceforge.net/How_to_turn_a_REBOL_script_into_EXE

NSIS est téléchargeable ici :    http://nsis.sourceforge.net/

Après l'installation, allez dans le répertoire où se trouve votre NSIS.

Créez un répertoire : Rebol dans lequel vous mettrez vos scripts NSIS et les autres fichiers.



Copiez-y votre script REBOL hello.r et aussi les fichiers nécessaires.

Créez-y également un fichier texte (->Nouveau Document) et appeler le : hello.nsi



Vous pouvez aussi mettre un fichier icône (ici, hello.ico est optionnel).

Ouvrez avec un éditeur de texte le fichier et faites un copier-coller du texte :

	; Nom de l'installateur
Name "Hello"
; On ne veut pas de fenêtre, juste l'exécution des fichiers
SilentInstall silent
; Le nom de l'exécutable
OutFile "Hello.exe"
; Pour définir une icône (optionnel)
;Icon "hello.ico"
; Le répertoire d'installation
InstallDir "$TEMP\hello"
; Ce qui va être installé
Section ""
; Le chemin du répertoire d'installation.
SetOutPath $INSTDIR
; la liste des fichiers requis
File "rebol.exe"   ; a REBOL interpreter
File "hello.r"   ; put one or more REBOL script(s)
; On exécute et on attend la fin du script
ExecWait '"$INSTDIR
ebol.exe" "-s" "$INSTDIR\hello.r"'
; On efface les fichiers pour terminer
RMDir /r $INSTDIR
SectionEnd


Enregistrez le fichier et avec un clic-droit, lancer la compilation du script
avec NSIS.



Le compilateur NSIS vous informe des erreurs ou du succés :



Vous pouvez alors tester l'exécutable créé, soit directement depuis le compilateur,
soit en cliquant sur l'exécutable.

tester hello.exe


Le déclenchement de l'exécution produit les étapes suivantes :

  1. ouverture de hello.exe

  2. décompactage des fichiers rebol.exe et hello.r dans le répertoire d'installation $INSTDIR
    (qui ici est C:\temp\hello et est créé à la volée).

  3. exécution de la commande ExecWait "rebol.exe -s hello.r" dans $INSTDIR

  4. A la fin de l'exécution, suppression des fichiers et du répertoire $INSTDIR.


Avantages et inconvénients

  • Il est possible d'avoir une icône.
  • la liste des fichiers peut être conséquente

  • L'exécution du script se fait via la VM REBOL : le décompactage, puis
    l'exécution du script s'en ressentent.


Cela reste une solution élégante, avec peu de moyens. NSIS permet
par ailleurs de faire des tas d'autres choses, mais c'est une autre histoire...

Comment créer un exécutable en Rebol ? 1/4

Une question qui revient souvent sur les forums est :

Comment créer un exécutable en Rebol ?



Il existe plusieurs manières de faire un exécutable. J'en connais au moins 4, que je vais détailler ici.
Pour cela, j'utiliserai un fichier ultra-simple : hello.r dont le contenu est le suivant :

	REBOL[]
print "HELLO"
wait 5


Les présentations sont faites sous Windows XP SP2.

Utiliser Rebol/Encap

Utiliser l'encapsuleur adapté


Tout d'abord, REBOL Technologies permet de créer un exécutable en utilisant Rebol/Encap, qu'on trouve soit dans le SDK, soit dans la version Pro ou Command. Dans tous les cas, cela suppose d'avoir une license (fichier license.key) valide dans le même répertoire que l'encapsulateur.
(Si c'est votre cas, eh bien, vraisemblablement, vous n'avez pas besoin de ce tutoriel)
Placez vous dans le répertoire où se REBOL/Encap, c'est à dire votre répertoire d'installation du SDK ou Pro, dans le répertoire bin.

Vous pouvez utiliser les fichiers enbase.exe, encmd.exe, enface.exe, et enpro.exe suivant l'environnement REBOL souhaité (Base, Face, Command, Command/pro).



Double-cliquez sur enbase.exe, qui est suffisant pour notre exemple.

Une fenêtre s'ouvre pour demander le chemin du fichier source


puis propose un nom (construit par défaut à partir du nom du fichier source) pour l'exécutable.



Note :
Le nom du fichier source doit être tapé tel quel.
Pas de symbole "%", ni de guillemets ou de quotes.

Plusieurs d'informations s'affichent (dont les erreurs) :



Et le fichier est créé avec le nom souhaité.

Paramétrages possibles

Suivant le cas, il peut s'avérer nécessaire d'inclure des fichiers. Soit pour rajouter le dialecte View à partir de enface, soit pour rajouter des modules (ex. le driver MySQL de DocKimbel).

Ceci peut se faire avec la commande #include qui spécifie au pré-processeur de l'encapsulateur d'inclure le fichier cité.

#include %../rebol-sdk-cmd/source/view.r


Cette commande doit être inscrite dans votre script au tout début.

Un nom particulier

Il est possible - pour les versions graphiques - d'utiliser dans l'en-tête du script REBOL source des mots-clés spéciaux pour l'encapsulateur :

	REBOL[
Title: "Salut"
Encap: [title "mon titre à moi " quiet secure none]
]


Cette chaîne de caractères "mon titre à moi" apparaîtra dans les fenêtres de l'exécutable.

Inconvénients de cette méthode


  • Il y a parfois des bugs incompréhensibles
  • Il n'est pas possible d'avoir une icône particuliére
  • la gestion du nom dans le bandeau des fenêtres n'est pas triviale


La suite bientôt ...


vendredi 06 octobre 2006

Souvenirs...

Quelques photos souvenirs de la rencontre du 30 juin 2006 à Paris avec Carl et Cindy :




(François Jouen et Carl)




(Carl et Cindy)



(Dockimbel, JJ Valognes, et François)

===Philippe

mercredi 09 août 2006

Utility from Gabriele

Sur Altme, Gabriele a posté un lien vers un script de fonctions-utilitaires :

http://www.colellachiara.com/soft/libs/utility.r

Voir en particulier la fonction Nforeach qui permet de boucler sur N séries en même temps :

NFOREACH is a generalization of the FOREACH function; it can loop
over multiple series at the same time. The first argument is a block
of words and series, in pairs. The first element can be a word, a
get-word evaluating to a word or a block, or a block. The meaning
is the same as the first argument of the FOREACH function. The second
element is evaluated and must evaluate to a series value. Examples:
    nforeach [a [1 2 3] b [4 5 6]] [
        print [a b]
    ]
    ; will print:
    ; 1 4
    : 2 5
    ; 3 6
    ;
    block1: [1 2 3]
    block2: [4 5 6]
    nforeach [a block1 b block2] [
        print [a b]
    ]
    ; will print same as above
    ;
    nforeach [[a b] [1 2 3 4 5 6] c [7 8 9]] [
        print [a b c]
    ]
    ; will print:
    ; 1 2 7
    ; 3 4 8
    ; 5 6 9
    ;
    nforeach [[a b] join block1 block2 c [7 8 9]] [
        print [a b c]
    ]
    ; will print same as above
    ;
    word: 'a
    nforeach [:word [1 2 3]] [
        print a
    ]
    ; will print:
    ; 1
    ; 2
    ; 3
}

Redirections

Imaginons que dans un script vous vouliez que les affichages sur la sortie standard (avec print par exemple),
soient récupérés, soit dans une variable, soit dans un autre script. Comment faire ?
Par exemple, vous voulez expérimenter un script CGI, mais vous n'avez pas de serveur Web, vous voulez juste voir l'affichage renvoyé par le script REBOL cgi.
Ou bien juste débugger localement un script.

Cas numéro 1 :

Dans le cas où vous souhaitez récupérer le contenu de la sortie standard,
et le mettre ensuite dans une variable utilisable ,
vous pouvez utiliser le code suivant de Dockimbel (http://www.reboltech.com/library/html/capture.html)

Le code de DocKimbel, déclaré dans le contexte ctx-console-capture :
ctx-console-capture: context [
		out: none
		sys-print: get in system/words 'print
		sys-prin:  get in system/words 'prin
		
		set 'get-captured does [out]
		
		print-out: func [value][append out reform [reduce value newline]]
		prin-out:  func [value][append out reform value]
		
		set 'capture func [flag [logic!]][
			either flag [
				out: make string! 1024
				set 'print :print-out
				set 'prin :prin-out
			][
				set 'print :sys-print
				set 'prin  :sys-prin
			]
		]
	]    

Le principe est le suivant :
Une fonction "capture" est activée par :
	capture on
Dans ce cas, tout ce qui va sur la sortie standard avec prin ou print est ajouté (APPPEND) à une variable locale : out.
Pour arrêter la capture, il suffit d'un :
	capture off
Le contenu capturé est finalement visible dans une variable globale : get-captured.
Il est ainsi possible localement d'activer cette fonction et de consulter après les informations.

Cas numéro 2 :

Ici, vous avez deux scripts.
Toutes les informations qui vont sur la sortie standard (stdout), via des PRINT ou PRIN, doivent être récupérées un second script, et utilisées.
Bien qu'il y ait plusieurs manières de faire, en voici une qui utilise les redirections système.
Vous savez sans doute qu'il est possible de rediriger les entrées et sorties standard système (stdin, stdout).
Carl en parle par exemple dans son Blog (http://www.rebol.net/article/0004.html).
Typiquement, créez un script en shell (suivant votre OS) qui contiendra le code suivant :
		rebol.exe -wq code.r >infile.txt <outfile.txt 
Les options de ligne de commande sont : -wq, c'est à dire : "tais-toi et n'ouvre pas de console".
Ici, le contenu de infile.txt va être passé en stdin (entrée standard) au script code.r,
et celui-ci va renvoyer sa sortie standard (stdout) vers le fichier outfile.txt (recréé à chaque utilisation).

Exemple de fichier infile.txt :
	print "HELLO WORLD"
	blk: copy system/locale/months
	foreach m blk [print m]
Ici, le fichier entier est passé au script code.r, qui va évaluer son contenu et renvoyer tout vers stdout (c.à.d. outfile.txt).
Exemple de fichier code.r :
	REBOL[]

	print "DEBUT TEST"

	set-modes system/ports/input [lines: false binary: false]
	buffer: copy system/ports/input
	do buffer

	print "FIN TEST"
	quit
Dans ce code, l'entrée standard (system/ports/input) est mise dans un buffer et celui-ci est évalué.
Les sorties (print "DEBUT TEST" par exemple) sont renvoyées vers le fichier outfile.txt.

Le contenu d'outfile.txt :
	DEBUT TEST
	HELLO WORLD
	January
	February
	March
	April
	May
	June
	July
	August
	September
	October
	November
	December
	FIN TEST


Et en plus :

Il est possible aussi d'utiliser une redirection stdout depuis REBOL
	
      system/ports/output: open/direct %log.txt

va renvoyer tous les affichages vers %log.txt

Egalement, l'usage de :
	
      data: read console://
va ouvrir (via le scheme 'console) stdin en lecture. Tout ce qui est tapé dans la console est stocké dans la variable data.
Un break dans la console, suivi d'un print data renvoie ce qui a été saisi.

Et voilà !

===Philippe

lundi 26 juin 2006

Either again

J'ai déjà montré précedemment l'intérêt de la fonction either.

Voici une autre illustration, provenant de Gabriele, et du Rebol TalkForum.

>> x: 1
== 1
>> do either x < 5 ['add]['multiply] 3 4
== 7


Ici, lorsque le test sur la valeur de x est true, c'est la fonction add qui est appelée, d'où le résultat : do 'add 3 4.
Sinon ce serait la fonction multiply et on aurait : do 'multiply 3 4, soit 12.

C'est l'usage des fonctions sous la forme de mots renvoyés par le test, puis évalués, que j'ai trouvé intéressante.

===Philippe

jeudi 11 mai 2006

Un pseudo objet face

Utilisé dans View, face est un raccourci pour system/standard/face qui contient 26 attributs de premier niveau, dont feel, para, size, edge, color, etc.
face est un object! au sens REBOL :
	type? face
== object!

Question : Est-il possible de créer à partir d'un vrai objet REBOL (ou d'un contexte , ou un module ?) un objet face minimaliste ? Quels sont les attributs critiques pour générer une face ?

A priori, le type est important :
	>>dd: make object! [type: face]
>> view dd
** Script Error: Invalid path value: text
** Where: view
** Near: view-face/text: any [
view-face/text
all [system/script/header system/script/title]
copy ""
]
new: all

D'après le message d'erreur, il faut aussi rajouter l'attribut text :
	>> dd: make object! [type: face text: "essai face"]
>> view dd
** Script Error: Invalid path value: feel
** Where: view
** Near: view-face/feel: window-feel

Ici on voit que cette fois-ci, c'est l'attribut feel (un objet) qui manque. Rajoutons-le :
	>> dd: make object! [type: 'face text: "essai face" feel: none]
>> view dd
** User Error: bad face in screen pane!
** Near: show scr-face
if new [do-events]

Après tâtonnements :
Un objet face minimaliste doit comprendre les attributs suivants :
	simple-face: make object! [
type: 'face      ; mandatory
offset: 40x40   ; mandatory
size: 200x100   ; mandatory
span: none    ; mandatory
pane: none  ; mandatory
text: "un essai d'objet de type 'face"  ; mandatory  (erreur titre)
color: 255.200.200   ;(black by default if no color attribute)
feel: make object! [ ]   ; erreur si feel absent
]

l'attribut color n'est pas obligatoire. Par défaut, la couleur sera : black, si color n'est pas spécifiée. Donc au minimum, pour créer une face à partir d'un objet, il suffit de 7 attributs.
Type, offset et size, span et pane, text pour le titre de la fenêtre, et feel, déclaré comme objet.

A quoi cela sert-il ? A rien. Juste de la curiosité.

===Philippe

mardi 02 mai 2006

3Flex : le retour

3Flex est l'un des tous premiers programmes en REBOL qui m'a épaté.
Le code permet de tracer des diagrammes au moyen de blocs reliés par des fléches.

3flex

Il est possible de récupérer la dernière version de ce programme sur le site de Chris Langreiter :

Lien vers 3flex

Cependant, depuis 2003, le programme n'a pas évolué. Il souffre en effet d'un bogue dans l'éditeur de noeuds, incompatible avec les versions récentes de View. Dans le passé, j'avais cherché à trouver ce bogue, mais faute d'expérience suffisante, j'avais abandonné.
Mais il y a quelques jours, je suis retombé sur une archive avec 3Flex.
Et j'ai répété le bogue avec View 1.3.2. En regardant le code, tout à coup, quelques erreurs m'ont sauté aux yeux.
Et hop !

Voici les changements à apporter au code initial pour qu'il fonctionne :
Modifications à apporter :
------------------------------------------------
Dans lib\
-> node-editor-lib.r
modifier toutes les lignes : edge: 0x0 par : edge: make self/edge [size: 0x0]
-----------------------------------
Dans lib\category-editors\ :
->default.category-editor :
modifier toutes les lignes : edge: 0x0 par : edge: make self/edge [size: 0x0]
->node.category-editor :
modifier toutes les lignes : edge: 0x0 par : edge: make self/edge [size: 0x0]
------------------------------------
A la racine :
-> 3flex-13.r
modifier la ligne fill-pen: none par : fill-pen red

A la suite de ces changements, vous avez une version fonctionnelle.
Il est possible de l'améliorer assez vite, comme nous le verrons.
===Philippe

jeudi 02 février 2006

Affectation multiples

Salut,

(Ce post est une reprise d'une note postée sur Codeur.org)

Dans une fonction, on teste l'usage d'un raffinement "raff" par :

...
if raff [ faire quelque chose de particulier avec cette fonction ]
...


par ailleurs, il est possible d'utiliser either plutôt que if, ce qui agrandit le comportement particulier lié au raffinement :

...
either raff [
faire quelque chose de particulier avec cette fonction
][
sinon faire autre chose
]
...


L'un des usages de either est de permettre d'attribuer une valeur à un mot. Plutôt que de faire :

...
either raff [ var1: green ][var1: red]
...


Rebol Tech. suggère de faire ceci :

...
var1: either raff [ green ][ red ]
...


ce qui est plus lisible, et revient à dire : var1 prendra la valeur green ou red, selon que le raffinement raff (ou autre test logique) est utilisé ou non (true ou false).
J'aime bien cette forme car elle est très synthètique.
Mais le probléme, c'est que parfois, c'est aussi restrictif.
Si on vaut assigner deux variables selon le résultat du test, on pourrait penser écrire quelque chose comme cela :

var1: either raff [ green ][ red ]
var2: either raff [ yellow ][ blue ]


ou sinon :

either raff [ var1: green var2: yellow ][ var1: red var2: blue ]


mais cela revient à effectuer deux fois le test logique ou pire, et là je pense que Marco me ferait les gros yeux ;-))

A ce problème terrible, voici une solution, (il y a peut-être mieux, on fait du rebol, n'est-ce pas ?), qui à mon avis est extensible à n variables, pourvu qu'on garde les blocs à attribuer *en sortie* des blocs évalués avec either.

; test logique vrai, c'est le premier cas qui est ok
; avec une forme condensée simple.
raff: true
set ['var1 'var2] either raff [[green red]][[yellow blue]]
probe var1   ; green
probe var2   ; red


; test logique faux, c'est le second cas qui est ok, avec ici
; du code **avant** les blocs finaux
raff: false
set ['var1 'var2] either raff [
size: 10x20
offset: 45x20
[green red]
][
toto: "test"
my-url: http://mon-site.com
[yellow blue]
]
probe var1   ; yellow
probe var2   ; blue


Pratique, par exemple, lorsque'on veut récupérer la size, l'offset, le texte et autres attributs d'une face selon des conditions.
Mais utilisable dans bien d'autres cas, je pense.
Voilà, c'est tout, je voulais juste partager cette petite méditation logique avec vous.

===Philippe

- page 2 de 3 -