From fe449618f08a2ccfcfdd68a80e6f40080d801e0a Mon Sep 17 00:00:00 2001
From: Suwako Moriya <suwako@moriya.zapto.org>
Date: Thu, 28 Feb 2019 17:03:42 +0100
Subject: [PATCH] [fractale module] Implemented parse function (approximately)

---
 modules/fractale.py | 136 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 111 insertions(+), 25 deletions(-)

diff --git a/modules/fractale.py b/modules/fractale.py
index dfb12e2..7f2dc7e 100644
--- a/modules/fractale.py
+++ b/modules/fractale.py
@@ -19,37 +19,123 @@ class MainClass():
         self.description="Module de génération de fractales"
         self.interactive=True
         self.color=0x78ffc3
+        self.fractals={
+            "von_koch_curve_flake":{"Type":"Figures", "Max":((5000,5000), 5000, 10), "Min":((0,0),0,1), "Default":"(2500 2500) 2000 5 #ffffff 1", "Indication":"(départ) (arrivée) longueur iterations color bg stroke", "ParseData":"pfixi"},
+            "von_koch_curve":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1), "Default":"(0 2500) (5000 2500) 5 #ffffff 1", "Indication":"(départ) (arrivée) iterations color bg stroke", "ParseData":"ppixi"},
+            "blanc_manger":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1), "Default":"(1000 1000) (4000 4000) 7 #ffffff 1", "Indication":"(départ) (arrivée) iterations color bg stroke", "ParseData":"ppixi"},
+            "dragon":{"Type":"Lsystem", "Max":((5000,5000), 2500,19), "Min":((0,0),1,1), "Default":"(2500 2500)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
+            "sierpinski_triangle":{"Type":"Lsystem", "Max":((5000,5000),2500,11), "Min":((0,0),0,1), "Default":"(0 0)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
+            "fractal_plant":{"Type":"Lsystem", "Max":((5000,5000),2500,8), "Min":((0,0),0,1), "Default":"(0 2500)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
+            "koch_curve_right_angle":{"Type":"Lsystem", "Max":((5000,5000),2500,9), "Min":((0,0),0,1), "Default":"(0 5000)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
+            "fractal_binary_tree":{"Type":"Lsystem", "Max":((5000,5000),2500,15), "Min":((0,0),0,1), "Default":"(0 0)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"}
+            }
         self.help="""\
  </prefix>fractale [fractale] [nombre d'itérations]
  => Génère une image fractale. (Si on met le nombre d'itérations, on doit mettre le nom de la fractale.)
  
- -> Valeurs possible pour [fractale] + nb d'itérations max entre parentheses
+ -> Valeurs possible pour [fractale]
 ```..: Toutes les fractales:
-......: von_koch_curve_flake (7)
-......: von_koch_curve       (7)
-......: blanc_manger         (20)
-......: dragon
-......: sierpinski_triangle
-......: fractal_plant
-......: koch_curve_right_angle
-......: fractal_binary_tree```
-"""
-        self.fractals={
-            "von_koch_curve_flake":{"Type":"Figures", "Max":((5000,5000), 5000, 10), "Min":((0,0),0,1)},
-            "von_koch_curve":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1)},
-            "blanc_manger":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1)},
-            "dragon":{"Type":"Lsystem"},
-            "sierpinski_triangle":{"Type":"Lsystem"},
-            "fractal_plant":{"Type":"Lsystem"},
-            "koch_curve_right_angle":{"Type":"Lsystem"},
-            "fractal_binary_tree":{"Type":"Lsystem"}
-            }
+%s```"""%'\n'.join(['......: %s'%t for t in self.fractals.keys()])
+
+
+    def parse(self, inp):
+        retDic={"Success":False, "Message":"", "Result":()}
+        #Parsing the fractal name and storing the corresponding dic into a variable
+        try:
+            fractal=self.fractals[inp.split(' ')[0]]
+        except KeyError:
+            retDic.update({"Success":False, "Message":"La fractale %s n'existe pas."%inp.split(' ')[0]})
+            return(retDic)
+        arg=' '.join(inp.split(' ')[1:]) #Stuff after the fractal name
+        #checking for incoherent parentheses usage
+        parentheses_count=0
+        for i,char in enumerate(arg):
+            if char=='(':
+                parentheses_count+=1
+            elif char==')':
+                parentheses_count-=1
+            if not(-1<parentheses_count<2):
+                retDic.update({"Success":False, "Message":"Usage invalide de parentheses au charactère numéro %s (à partir d'après le nom de la fractale)."%i})
+                return(retDic)
+
+        #Here, we have a coherent parentheses usage
+        if ',' in arg:
+            retDic.update({"Success":False, "Message":"Les virgules n'ont pas leur place dans les paramètres de génération. Il ne doit y avoir que des espaces uniques."})
+            return(retDic)
+
+        #parsing the fractal
+        args=arg.replace(')','').replace('(','').split(' ')
+        parsed_args=[]
+        i=0
+        for parse in fractal['ParseData'] :
+            if parse=='p':
+                if args[i]!='*':
+                    try:
+                        int(args[i])
+                        int(args[i+1])
+                    except:
+                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (nombre entiers attendus pour les coordonnées d'un point)"})
+                        return(retDic)
+                    parsed_args.append((int(args[i]),int(args[i+1])))
+                    i+=2
+                else:
+                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
+                    i+=1
+
+            elif parse=='f':
+                if args[i]!='*':
+                    try:
+                        float(args[i])
+                    except:
+                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Nombre à virgule flottante attendu (mettre un point pour la virgule))"})
+                        return(retDic)
+                    parsed_args.append(float(args[i]))
+                    i+=1
+                else:
+                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
+                    i+=1
+
+            elif parse=='i':
+                if args[i]!='*':
+                    try:
+                        int(args[i])
+                    except:
+                        print(args[i])
+                        print(i)
+                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Nombre entier attendu)"})
+                        return(retDic)
+                    parsed_args.append(int(args[i]))
+                    i+=1
+                else:
+                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
+                    i+=1
+
+            elif parse=='x':
+                if args[i]!='*':
+                    try:
+                        if '#' in args[i]:
+                            int(args[i].replace('#','0x'),16)
+                        else:
+                            raise
+                    except:
+                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Valeur hexadécimale attendue)"})
+                        return(retDic)
+                    parsed_args.append(int(args[i].replace('#','0x'),16))
+                    i+=1
+                else:
+                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
+                    i+=1
+        retDic.update({"Success":True, "Result":parsed_args})
+        return(retDic)
+
     async def on_message(self, message):
+        #await message.channel.send(str(self.parse(message.content[len("%sfractale "%self.prefix):])))
+        #ħere
         args=message.content.split(" ")
         tmpstr="/tmp/%s.png"%random.randint(1,10000000)
-        im=Image.new('RGB', (5000, 5000), (0, 0, 0))
-        fig = fractale.source.main.Figures(im=im)
+        im=Image.new('RGB', (5000, 5000), (0, 0, 0))#here
         
+        fig = fractale.source.main.Figures(im=im)#here
         if len(args)==1 :
             await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve_flake,*((2500, 2500), 2000, 5))
         elif args[1].lower()=="blanc_manger" :
@@ -69,7 +155,7 @@ class MainClass():
             await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve,*((0, 2500), (5000,2500), iterations))
         else:
             await self.modules['help'][1].send_help(message.channel, self)
-            return
-        im.save(tmpstr)
+            return#here
+        im.save(tmpstr)#here
         await message.channel.send(file=discord.File(tmpstr))
-        os.remove(tmpstr)
+        os.remove(tmpstr)#here