Discussion :

[bafac]

Salut à tous,

Je viens de me mettre à Ruby, et je n'ai avec aucun antécédent en programmation (soyez indulgent).

J'ai donc réalisé une simple To Do list, comprenant tâches et deadlines, et s'enregistrant dans un fichier. C'est tout simple, mais ça marche et je suis content.

Je souhaiterais, toutefois, avoir des feedbacks de programmeurs plus expérimentés sur la "structure" de ce programme. Je fais probablement des erreurs monstrueuses, et je voudrais les corriger avant de prendre de mauvaise habitudes. Je suis donc prêt à recevoir toutes vos remarques sur le code ci-dessous.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
class TodoList
 
    def initialize #Charge et stocke le fichier dans une array
        @array_tasks = []
        File.open("ToDoListFile", "r") do |line|
            line.each do |text|
                @array_tasks << text.to_s.split(",")
            end
        end
    end
 
 
    def lire #Montrer toutes les taches dans l'array
        puts "|----------------------------"
        @array_tasks.each do |task|
            puts "=> #{task[0]}"
            puts "                Deadline: #{task[1]}"
        end
        puts "|----------------------------"
    end
 
 
    def ecrire #Cree une nouvelle tache et l'ajoute dans l'array
        puts "Quelle est la nouvelle tache?"
        nouvelle_t = gets.chomp
        puts "Quelle est la deadline?"
        deadline = gets.chomp
        @array_tasks << [nouvelle_t, deadline]
    end
 
 
    def supprimer #Supprime une tache dans l'array
        n = 0
        @array_tasks.each do |task| #Afficher les numeros des taches
            puts "#{n}: #{task[0]}"
            n += 1
        end
 
 
        puts "Supprimer tache N?" #Choisir et supprimer une tache
        suppr = gets.chomp.to_i
        @array_tasks.delete_at(suppr)
 
 
    end
 
 
    def enregistrer #Enregistre l'array dans le fichier
        File.open("ToDoListFile", "w") do |line|
            @array_tasks.each {|task| line.puts "#{task[0]},#{task[1]}"}
        end
    end
 
 
    def update
        n = 0
        @array_tasks.each do |task| #Afficher les numeros des taches
            puts "#{n}: #{task[0]}"
            n += 1
        end
 
 
        puts "Modifier la tache N?"
        modif = gets.chomp.to_i
        puts "Changer le libelle ou la deadline? (l ou d)"
        modif_ld = gets.chomp
        case modif_ld
        when "l"
            puts "Nouveau libelle de la tache?"
            nouveau_libelle = gets.chomp
            @array_tasks[modif][0] = nouveau_libelle
        when "d"
            puts "Nouvelle deadline?"
            nouvelle_deadline = gets.chomp
            @array_tasks[modif][1] = nouvelle_deadline
        else
            puts "Mauvaise commande..."
        end
    end
 
 
 
 
end
 
 
 
 
MyTDL = TodoList.new #Création de l'instance
choix = ""
 
 
#Interface et choix de l'utilisateur
until choix == "end"
    puts "_______________________"
    puts "Choisis ton action:"
    puts "a - Ajouter une tache"
    puts "l - Afficher les taches"
    puts "u - Modifier une tache"
    puts "s - Supprimer une tache"
    puts "r - Enregistrer les changements"
    puts "end - Fin du programme"
    choix = gets.chomp
 
 
    case choix
    when "a"
        MyTDL.ecrire
    when "l"
        MyTDL.lire
    when "r"
        MyTDL.enregistrer
    when "s"
        MyTDL.supprimer
    when "u"
        MyTDL.update
    else
        puts "Mauvaise commande..."
    end
end

Merci pour vos commentaires

[abelar_s]

Bonjour Bafac,
bravo et bon courage pour ton arrivée dans le monde Ruby

À titre perso j'avais fait des outils comme ça (en shell !) pour gérer mes TODO un peu comme un org-mode.
Alors je te propose deux exercices pour améliorer tout ça

EXERCICE 1 - refactoring
Je mettrais les lignes 90 à 120 dans ta classe. Par exemple :
- une méthode "help" qui te sortira l'aide
- une méthode "commande" qui exec les commandes (normalement tu voudras y ajouter des messages d'erreur)
- une méthode "console" ou "run" qui te fait la boucle d'input envoie les commandes à "commande" (d'autres erreurs spécifiques sont possibles aussi)

Ainsi il ne restera plus qu'une commande à la fin, hors de ta classe : MyTDL.new.console
Ça te fera déjà un petit exercice de refactoring


EXERCICE 2 - shell UNIX

Justement, on vise à utiliser ça dans un shell. Ce que je te propose alors c'est de gérer ça en philosophie Unix : ton outil est appelé puis quitte entre chaque appel sur ta ligne de commande, et tu te bases sur le shell de la personne pour tourner.

Ça te forcera à faire les choses un peu différemment et ne plus te baser sur l'input mais les ARGS unix.
Il te faudra une méthode pour afficher l'aide (hey, tu en as déjà une !), une pour faire les commandes (déjà faite !) et la console deviendra obsolète.

Je te propose de t'inspirer de ce super talk de George Brocklehurst sur les conventions Unix en Ruby :
http://rawgit.com/georgebrock/talks/...uby/index.html
- faire un message d'aide
- de beaux messages d'erreur
- utiliser les bons file descriptors (sortie standard, sortie d'erreur)
- codes de retour (0 si tout va bien, un numéro positif par type d'erreur géré : mauvaise commande, mauvais arguments, etc)


Voilà, ça devrait déjà te mettre devant pas mal de petits succès mais aussi suffisamment de problèmes pour t'aider à bien avancer !
Bon courage,