Best Free Web Developer Tool for Debugging

Voici un lien vraiment très intéressant, concernant un panel ( et non une fulltitude ) d'outils pour debugger des applications Web. Safari, Firefox, Opera et même Internet Explorer possèdent des outils permettant à nos amis web developer de se faciliter la vie.Bonne lecture

read more | digg story

à la SOAP: le dessert

Vous souvenez-vous, dans mon précédent billet, j'indiquais que j'allais devoir utiliser mouseHole afin de vérifier le bon fonctionnement d'un connecteur SOAP.

J'étais prêt à mettre la main à la pate, quand tout à coup, j'ai trouvé soapUI.

Il s'agit d'un outil de test pour WebServices. A première vue, il avait l'air simple, mais j'ai pû constater qu'il était génial. Importer mon WSDL, générer un mock webservice et tester mon connecteur en quelques minutes, sans écrire une seule ligne.
Je ne vous dis pas la joie que j'ai pû ressentir en me disant que j'avais gagné quelques jours de développement à cause d'un manque d'outil pour debugger mes messages SOAP.

La chose vraiment intéressante, il est possible de scripter cet outil via Groovy afin de modifier les responses à la volée.
Sincèrement, j'avais la bouche ouverte :d

à la SOAP

Voilà, pour le boulot, je vais devoir créer un connecteur SOAP. La partie la plus marrante, c'est que je ne dispose pas d'outils pour vérifier mes messages. Donc, je me suis entrain de penser à écrire un proxy http écrit en ruby, et qui fera intermédiaire entre moi et le webservice que je dois attaquer.

Je vais essayer tout à l'heure cet outil : mouseHole
J'espère que son utilisation m'aidera, car de cette manière, il m'aidera à valider mon code plus rapidement.

Pour ne pas oublier, je développe principalement en C++ Builder 6 et Delphi 7. Je n'ai pas le choix, c'est les choix technologiques de mon employeur.

WIN32OLE Le retour :-)

Je viens de découvrir une méthode de classe très intéressante, surtout qu'elle appartient à la classe WIN32OLE. Il s'agit de la méthode

WIN32OLE::const_load( ole_object, module_or_class )

Vous souvenez-vous du code de mon précédent article ? J'avais défini un ensemble de constantes hiérarchisées à l'aide de modules.

module Word 
  module PageSetup
    module Orientation
      Portrait = 0
      Landscape = 1
    end
  end
  .....
end

En découvrant cette méthode, j'ai pû refactoriser mon code, afin de le rendre plus lisible et d'utiliser directement les constantes définies par la couche OLE. Voici donc, un peu de refactorisation de mon précédent code.

# Définition d'un module qui va servir à agréger les différentes constantes 
# qui sont définie dans le composant OLE de Word.
module Word
end

begin
    word = WIN32OLE.new( "Word.Application" )
    # Lé méthode WIN32OLE::const_load charge les différentes constantes 
    # qui peuvent être chargées depuis l'instance Word.
    # De cette manière, il n'est pas nécessaire que je crée un ensemble 
    # de constantes pour représenter toutes les valeus possibles.
    WIN32OLE.const_load( word, Word )

    document = word.Documents.Add()
    document.PageSetup.PaperSize = Word::WdPaperA4
    document.PageSetup.Orientation = Word::WdOrientLandscape
ensure
    word.Quit()
end

Je vous donne un avis, je n'ai pas pû complètement la documentation lors de l'article précédent, ce qui m'a fait perdre du temps. Un conseil, lisez les exemples, la documentation et tout ce qui peut aider. Références

• WIN32OLE::const_load

autosubst 1.0

Il y a quelques mois, j'ai écris cet article. Je profite donc de ce nouveau blog pour vous en faire part ;)

Ruby , OLE et Word

Comment générer des documents Word avec OLE et Ruby ? Je vais être honnête avec vous, je ne suis pas pour l'utilisation de Word, mais les personnes travaillant avec moi, utilisent majoritairement cet outil et ne jurent que par celui-ci. Afin d'utiliser correctement OLE avec Ruby, il faut avoir à sa disposition plusieurs outils, :-)

• win32ole Elle fait partie de la librairie standard de Ruby et d'une très grande utilité ;-) sans ça, il est impossible de pouvoir utiliser Word via OLE.
• ole_browser.rb qui est un script permettant d'introspecter les objets disponibles. Cet outil a été écrit par Dave Burt et Masaki Suketa.

#!/usr/bin/env ruby
require "win32ole"

Définition d'une nouvelle méthode basée sur l'opérateur '/' afin de sucharger la classe String.

class String
 def / ( other )
   File.join( self, other )
 end
end

Etant donné que je n'avais pas envie d'écrire tout le temps du code inutilement, et que j'adore refactoriser, j'ai ajouté une petite méthode au module Kernel. Celle me permet de gagner un peu de lisibilité, mais pas grand chose, je la met dans la zone des Helpers.

module Kernel
 def with( obj )
   yield obj
 end
end

Bon, commençons par le plus intéressant, je pense que le plus intéressant est tout de même de charger Word :D donc, voici comment charger cet outil.

word = WIN32OLE.new( "Word.Application" )

Dans mon exemple, je ne veux pas voir l'interface de Word, de ce fait, je n'active pas sa visibilité.

word.Visible = false

Etant donné que cet article parle de la création de document, il ne s'agit pas d'ouvrir un document Word et de lui rajouter des infos, on part de zéro.

document = word.Documents.Add()

Afin que vous ne soyez pas perdu dans des nombres magiques, j'ai ajouté une petite liste de constantes, permettant de cette manière une utilisation plus aisée des composants.

module Word
 module PageSetup
   module Orientation
     Portrait = 0
     Landscape = 1
   end
   module Size
     PaperA4 = 7
   end
 end

 module Font
   module ColorIndex
     Black = 1
     Blue = 2
     Turquoise = 3
     BrightGreen = 4
     Pink = 5
     Red = 6
     Yellow = 7
     White = 8
     DarkBlue = 9
     Teal = 10
     Green = 11
     Violet = 12
     DarkRed = 13
     DarkYellow = 14
   end
 end

 module ParagraphAlignment
   Left = 0
   Center = 1
   Right = 2
   Justify = 3
   Distribute = 4
   JustifyMed = 5
   JustifyHi = 7
   JustifyLow = 8
   ThaiJustify = 9
 end
end

Cette partie est bête, mais spécifie le format de la page, de cette manière j'indique le format A4 en Paysage ( LandScape )

document.PageSetup.PaperSize = Word::PageSetup::Size::PaperA4
document.PageSetup.Orientation = Word::PageSetup::Orientation::Landscape

Pour toutes les sections se trouvant dans le document, nous allons ajoutés un en-tête et un pied de page. Création de l'entête avec une police de caractères ayant la couleur Violet, et dont le contenu sera "En-tête d'exemple"

for section in document.Sections
 with section.Headers( 1 ).Range do |range|
   range.Font.ColorIndex = Word::Font::ColorIndex::Violet
   range.Text = "En-tête d'exemple"
 end
 with section.Footers( 1 ).Range do |range|
   range.ParagraphFormat.Alignment = Word::ParagraphAligment::Right
   range.Font.ColorIndex = Word::Font::ColorIndex::DarkRed
   range.Text = "Stephane Wirtel < stephane DOT wirtel AT gmail DOT com>"
 end
end

with word.Selection do |sel|
 # Ajout d'une image,
 picture = sel.InlineShapes.AddPicture( Dir.pwd() / 'change_directory.png', nil, true )

 # Bon, on insère un break, c'est à dire une nouvelle page
 sel.InsertBreak()

 [ "Je ne suis pas Superman, mais j'y arrive :D",
   "Une option en plus que les autres :D" ].each do |line|
   sel.TypeText( "#{line}\n" )
 end
 sel.InsertBreak()

 # Spécification de la taille de la police à utiliser
 with sel.Font do |font|
   font.Name = "Bitstream Vera Sans Mono"
   font.Size = 10
   font.Bold = false
 end

 # On ajoute l'heure avec la date de cette manière, on peut déjà savoir la date de création du document
 sel.TypeText( Time.now.to_s )
 sel.InsertBreak()
end

Et si on enregistrait le document, ça serait cool, vous ne pensez pas ? Tout ce travail pour ne pas le sauver, ça serait débile :D Donc, tadaaaaam

document.SaveAs( Dir.pwd() / 'test.doc' )
document.close()

Maintenant il ne reste plus qu'à fermer l'application Word, si nous ne le faisons pas, il restera une instance Word ouverte, ce qui peut provoquer des problèmes.

word.Quit()

Imaginez maintenant la création d'un DSL pour simplifier tout ce code, ou aussi l'utilisation de Textile