oktopios 0.0.1__tar.gz

oktopios-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mouanwiya Ali Soule
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oktopios-0.0.1/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: oktopios
+Version: 0.0.1
+Summary: Oktopios — un langage de programmation moderne et expressif 🐙
+Author: Mouanwiya Ali Soule
+License: MIT License
+        
+        Copyright (c) 2025 Mouanwiya Ali Soule
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/ALISOULEMOUANWIYA/oktopios
+Project-URL: Issues, https://github.com/ALISOULEMOUANWIYA/oktopios/issues
+Keywords: language,programming,interpreter,oktopios,okp
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: camelcase>=0.2
+Requires-Dist: psutil>=5.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+# 🐙 Oktopios
+
+> Un langage de programmation moderne, expressif et orienté objet, interprété en Python.
+
+---
+
+## Installation
+
+```bash
+pip install oktopios
+```
+
+Ou depuis les sources :
+
+```bash
+git clone https://github.com/mouanwiya/oktopios
+cd oktopios
+pip install -e .
+```
+
+## Utilisation rapide
+
+```bash
+# Exécuter un fichier
+okp mon_programme.okp
+
+# Code en ligne
+okp 'print("Bonjour 🐙")'
+
+# Mode interactif (REPL)
+okp --repl
+
+# Aide complète
+okp --help
+```
+
+## Syntaxe de base
+
+```okp
+// Variables et constantes
+var age: int = 25
+val nom: string = "Mouanwiya"
+
+// Fonctions
+fun saluer(prenom: string): string {
+    return "Bonjour " + prenom + " !"
+}
+print(saluer(nom))
+
+// Surcharge de fonctions
+fun calcule(a: int, b: int): int { return a + b }
+fun calcule(a: int, b: int, c: int): int { return (a + b) * c }
+
+// Lambdas
+val doubler = lambda(x: int) => x * 2
+print(doubler(5))   // 10
+
+// Boucles
+loop (i = 0; i < 5; i += 1) {
+    print(i)
+}
+
+// Classes
+class Animal {
+    var nom: string
+
+    fun __construct(n: string) {
+        this.nom = n
+    }
+
+    fun parler(): string {
+        return this.nom + " dit bonjour"
+    }
+}
+
+var chat = new Animal("Mimi")
+print(chat.parler())
+
+// Modules natifs
+inject Math as math
+inject String
+
+print(Math.sqrt(16))           // 4.0
+print(String.upper("hello"))   // HELLO
+```
+
+## Fonctionnalités
+
+- ✅ Variables typées (`var`, `val`)
+- ✅ Fonctions avec surcharge (overloading)
+- ✅ Lambdas et fonctions anonymes
+- ✅ Classes, interfaces, classes abstraites
+- ✅ Héritage, `override`, `super`
+- ✅ Énumérations
+- ✅ Modules natifs : `Math`, `String`, `Time`, `IO`, `List`, `Dict`...
+- ✅ Boucles avancées : `loop`, `filterLoop`, `sortLoop`, `permuteLoop`...
+- ✅ Gestion des exceptions (`try / catch / finally / throw`)
+- ✅ REPL interactif
+- ✅ Importation de fichiers `.okp`
+
+## Commandes CLI
+
+| Commande | Description |
+|---|---|
+| `okp fichier.okp` | Exécute un fichier |
+| `okp 'code'` | Exécute du code inline |
+| `okp --repl` | Lance le REPL |
+| `okp --check fichier.okp` | Vérifie la syntaxe |
+| `okp --version` | Affiche la version |
+| `okp --keywords` | Liste les mots-clés |
+| `okp --native` | Liste les fonctions natives |
+| `okp --doc` | Documentation intégrée |
+| `okp --init NomProjet` | Crée un projet |
+
+## Licence
+
+MIT © Mouanwiya Ali Soule

oktopios-0.0.1/README.md

@@ -0,0 +1,117 @@
+# 🐙 Oktopios
+
+> Un langage de programmation moderne, expressif et orienté objet, interprété en Python.
+
+---
+
+## Installation
+
+```bash
+pip install oktopios
+```
+
+Ou depuis les sources :
+
+```bash
+git clone https://github.com/mouanwiya/oktopios
+cd oktopios
+pip install -e .
+```
+
+## Utilisation rapide
+
+```bash
+# Exécuter un fichier
+okp mon_programme.okp
+
+# Code en ligne
+okp 'print("Bonjour 🐙")'
+
+# Mode interactif (REPL)
+okp --repl
+
+# Aide complète
+okp --help
+```
+
+## Syntaxe de base
+
+```okp
+// Variables et constantes
+var age: int = 25
+val nom: string = "Mouanwiya"
+
+// Fonctions
+fun saluer(prenom: string): string {
+    return "Bonjour " + prenom + " !"
+}
+print(saluer(nom))
+
+// Surcharge de fonctions
+fun calcule(a: int, b: int): int { return a + b }
+fun calcule(a: int, b: int, c: int): int { return (a + b) * c }
+
+// Lambdas
+val doubler = lambda(x: int) => x * 2
+print(doubler(5))   // 10
+
+// Boucles
+loop (i = 0; i < 5; i += 1) {
+    print(i)
+}
+
+// Classes
+class Animal {
+    var nom: string
+
+    fun __construct(n: string) {
+        this.nom = n
+    }
+
+    fun parler(): string {
+        return this.nom + " dit bonjour"
+    }
+}
+
+var chat = new Animal("Mimi")
+print(chat.parler())
+
+// Modules natifs
+inject Math as math
+inject String
+
+print(Math.sqrt(16))           // 4.0
+print(String.upper("hello"))   // HELLO
+```
+
+## Fonctionnalités
+
+- ✅ Variables typées (`var`, `val`)
+- ✅ Fonctions avec surcharge (overloading)
+- ✅ Lambdas et fonctions anonymes
+- ✅ Classes, interfaces, classes abstraites
+- ✅ Héritage, `override`, `super`
+- ✅ Énumérations
+- ✅ Modules natifs : `Math`, `String`, `Time`, `IO`, `List`, `Dict`...
+- ✅ Boucles avancées : `loop`, `filterLoop`, `sortLoop`, `permuteLoop`...
+- ✅ Gestion des exceptions (`try / catch / finally / throw`)
+- ✅ REPL interactif
+- ✅ Importation de fichiers `.okp`
+
+## Commandes CLI
+
+| Commande | Description |
+|---|---|
+| `okp fichier.okp` | Exécute un fichier |
+| `okp 'code'` | Exécute du code inline |
+| `okp --repl` | Lance le REPL |
+| `okp --check fichier.okp` | Vérifie la syntaxe |
+| `okp --version` | Affiche la version |
+| `okp --keywords` | Liste les mots-clés |
+| `okp --native` | Liste les fonctions natives |
+| `okp --doc` | Documentation intégrée |
+| `okp --init NomProjet` | Crée un projet |
+
+## Licence
+
+MIT © Mouanwiya Ali Soule

oktopios-0.0.1/oktopios.egg-info/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: oktopios
+Version: 0.0.1
+Summary: Oktopios — un langage de programmation moderne et expressif 🐙
+Author: Mouanwiya Ali Soule
+License: MIT License
+        
+        Copyright (c) 2025 Mouanwiya Ali Soule
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/ALISOULEMOUANWIYA/oktopios
+Project-URL: Issues, https://github.com/ALISOULEMOUANWIYA/oktopios/issues
+Keywords: language,programming,interpreter,oktopios,okp
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: camelcase>=0.2
+Requires-Dist: psutil>=5.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+# 🐙 Oktopios
+
+> Un langage de programmation moderne, expressif et orienté objet, interprété en Python.
+
+---
+
+## Installation
+
+```bash
+pip install oktopios
+```
+
+Ou depuis les sources :
+
+```bash
+git clone https://github.com/mouanwiya/oktopios
+cd oktopios
+pip install -e .
+```
+
+## Utilisation rapide
+
+```bash
+# Exécuter un fichier
+okp mon_programme.okp
+
+# Code en ligne
+okp 'print("Bonjour 🐙")'
+
+# Mode interactif (REPL)
+okp --repl
+
+# Aide complète
+okp --help
+```
+
+## Syntaxe de base
+
+```okp
+// Variables et constantes
+var age: int = 25
+val nom: string = "Mouanwiya"
+
+// Fonctions
+fun saluer(prenom: string): string {
+    return "Bonjour " + prenom + " !"
+}
+print(saluer(nom))
+
+// Surcharge de fonctions
+fun calcule(a: int, b: int): int { return a + b }
+fun calcule(a: int, b: int, c: int): int { return (a + b) * c }
+
+// Lambdas
+val doubler = lambda(x: int) => x * 2
+print(doubler(5))   // 10
+
+// Boucles
+loop (i = 0; i < 5; i += 1) {
+    print(i)
+}
+
+// Classes
+class Animal {
+    var nom: string
+
+    fun __construct(n: string) {
+        this.nom = n
+    }
+
+    fun parler(): string {
+        return this.nom + " dit bonjour"
+    }
+}
+
+var chat = new Animal("Mimi")
+print(chat.parler())
+
+// Modules natifs
+inject Math as math
+inject String
+
+print(Math.sqrt(16))           // 4.0
+print(String.upper("hello"))   // HELLO
+```
+
+## Fonctionnalités
+
+- ✅ Variables typées (`var`, `val`)
+- ✅ Fonctions avec surcharge (overloading)
+- ✅ Lambdas et fonctions anonymes
+- ✅ Classes, interfaces, classes abstraites
+- ✅ Héritage, `override`, `super`
+- ✅ Énumérations
+- ✅ Modules natifs : `Math`, `String`, `Time`, `IO`, `List`, `Dict`...
+- ✅ Boucles avancées : `loop`, `filterLoop`, `sortLoop`, `permuteLoop`...
+- ✅ Gestion des exceptions (`try / catch / finally / throw`)
+- ✅ REPL interactif
+- ✅ Importation de fichiers `.okp`
+
+## Commandes CLI
+
+| Commande | Description |
+|---|---|
+| `okp fichier.okp` | Exécute un fichier |
+| `okp 'code'` | Exécute du code inline |
+| `okp --repl` | Lance le REPL |
+| `okp --check fichier.okp` | Vérifie la syntaxe |
+| `okp --version` | Affiche la version |
+| `okp --keywords` | Liste les mots-clés |
+| `okp --native` | Liste les fonctions natives |
+| `okp --doc` | Documentation intégrée |
+| `okp --init NomProjet` | Crée un projet |
+
+## Licence
+
+MIT © Mouanwiya Ali Soule

oktopios-0.0.1/oktopios.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+oktopios.egg-info/PKG-INFO
+oktopios.egg-info/SOURCES.txt
+oktopios.egg-info/dependency_links.txt
+oktopios.egg-info/entry_points.txt
+oktopios.egg-info/requires.txt
+oktopios.egg-info/top_level.txt
+tests/test_interpreter.py
+tests/test_lexer.py
+tests/test_parser.py

oktopios-0.0.1/oktopios.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

oktopios-0.0.1/oktopios.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+okp = oktopios.vm.main:main

oktopios-0.0.1/oktopios.egg-info/requires.txt

@@ -0,0 +1,8 @@
+colorama>=0.4.6
+tabulate>=0.9.0
+camelcase>=0.2
+psutil>=5.9
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0

oktopios-0.0.1/oktopios.egg-info/top_level.txt

@@ -0,0 +1 @@
+

oktopios-0.0.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oktopios"
+version = "0.0.1"
+description = "Oktopios — un langage de programmation moderne et expressif 🐙"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+authors = [
+    { name = "Mouanwiya Ali Soule" }
+]
+keywords = ["language", "programming", "interpreter", "oktopios", "okp"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Interpreters",
+    "Intended Audience :: Developers",
+]
+dependencies = [
+    "colorama>=0.4.6",
+    "tabulate>=0.9.0",
+    "camelcase>=0.2",
+    "psutil>=5.9",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ALISOULEMOUANWIYA/oktopios"
+Issues   = "https://github.com/ALISOULEMOUANWIYA/oktopios/issues"
+
+[project.scripts]
+okp = "oktopios.vm.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["oktopios*"]
+
+[tool.setuptools.package-data]
+"oktopios" = ["metadata/*.txt", "metadata/*.md", "vm/modules/*.okp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]

oktopios-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

oktopios-0.0.1/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="oktopios",
+    version="0.0.1",
+    description="Oktopios — un langage de programmation moderne et expressif 🐙",
+    author="Mouanwiya Ali Soule",
+    license="MIT",
+    python_requires=">=3.10",
+    packages=find_packages(),
+    install_requires=[
+        "colorama>=0.4.6",
+        "tabulate>=0.9.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "okp=vm.main:main",
+        ],
+    },
+    include_package_data=True,
+    package_data={
+        "": ["metadata/*.txt", "metadata/*.md", "vm/modules/*.okp"],
+    },
+)

oktopios-0.0.1/tests/test_interpreter.py

@@ -0,0 +1,293 @@
+"""
+test_interpreter.py — Tests d'intégration de l'interpréteur Oktopios.
+"""
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "vm"))
+
+import pytest
+from lexer import tokenize
+from parser import Parser
+from interpreter import Interpreter
+
+
+def run(code: str, capsys=None):
+    tokens = list(tokenize(code))
+    ast = Parser(tokens).parse()
+    Interpreter().interpret(ast)
+    if capsys:
+        return capsys.readouterr().out.strip()
+    return None
+
+
+def out(code: str, capsys) -> str:
+    return run(code, capsys)
+
+
+# ── Valeurs primitives ────────────────────────────────────────────────────────
+
+def test_print_entier(capsys):
+    assert out("print(42)", capsys) == "42"
+
+
+def test_print_float(capsys):
+    assert out("print(3.14)", capsys) == "3.14"
+
+
+def test_print_string(capsys):
+    assert out('print("Bonjour")', capsys) == "Bonjour"
+
+
+def test_print_bool_true(capsys):
+    assert out("print(true)", capsys) == "true"
+
+
+def test_print_bool_false(capsys):
+    assert out("print(false)", capsys) == "false"
+
+
+# ── Arithmétique ──────────────────────────────────────────────────────────────
+
+def test_addition(capsys):
+    assert out("print(3 + 4)", capsys) == "7"
+
+
+def test_soustraction(capsys):
+    assert out("print(10 - 3)", capsys) == "7"
+
+
+def test_multiplication(capsys):
+    assert out("print(3 * 4)", capsys) == "12"
+
+
+def test_division(capsys):
+    result = out("print(10 / 4)", capsys)
+    assert float(result) == pytest.approx(2.5)
+
+
+def test_modulo(capsys):
+    assert out("print(10 % 3)", capsys) == "1"
+
+
+def test_priorite_ops(capsys):
+    assert out("print(2 + 3 * 4)", capsys) == "14"
+
+
+def test_parentheses(capsys):
+    assert out("print((2 + 3) * 4)", capsys) == "20"
+
+
+# ── Variables ─────────────────────────────────────────────────────────────────
+
+def test_var_int(capsys):
+    assert out("var x: int = 99\nprint(x)", capsys) == "99"
+
+
+def test_var_reassign(capsys):
+    assert out("var x = 1\nx = 2\nprint(x)", capsys) == "2"
+
+
+def test_val_immutable():
+    with pytest.raises(Exception):
+        run("val x = 5\nx = 6")
+
+
+def test_var_string(capsys):
+    assert out('var s = "ok"\nprint(s)', capsys) == "ok"
+
+
+def test_concat_string(capsys):
+    assert out('print("Hello" + " " + "World")', capsys) == "Hello World"
+
+
+# ── Fonctions ─────────────────────────────────────────────────────────────────
+
+def test_fun_call(capsys):
+    code = "fun double(n: int): int { return n * 2 }\nprint(double(5))"
+    assert out(code, capsys) == "10"
+
+
+def test_fun_default_param(capsys):
+    code = 'fun salut(nom: string = "ami") { print(nom) }\nsalut()'
+    assert out(code, capsys) == "ami"
+
+
+def test_fun_default_override(capsys):
+    code = 'fun salut(nom: string = "ami") { print(nom) }\nsalut("Ali")'
+    assert out(code, capsys) == "Ali"
+
+
+def test_fun_surcharge(capsys):
+    code = """
+fun f(a: int): int { return a }
+fun f(a: int, b: int): int { return a + b }
+print(f(5))
+print(f(3, 4))
+"""
+    lines = out(code, capsys).split("\n")
+    assert lines[0] == "5"
+    assert lines[1] == "7"
+
+
+def test_recursion(capsys):
+    code = """
+fun fact(n: int): int {
+    if(n <= 1) { return 1 }
+    return n * fact(n - 1)
+}
+print(fact(6))
+"""
+    assert out(code, capsys) == "720"
+
+
+def test_fun_imbriquee(capsys):
+    code = """
+fun externe() {
+    var msg: string = "Salut"
+    fun interne() { print(msg) }
+    interne()
+}
+externe()
+"""
+    assert out(code, capsys) == "Salut"
+
+
+# ── Lambda ────────────────────────────────────────────────────────────────────
+
+def test_lambda_simple(capsys):
+    assert out("val double = lambda(n: int) => n * 2\nprint(double(5))", capsys) == "10"
+
+
+def test_lambda_multi_param(capsys):
+    assert out("val add = lambda(a: int, b: int) => a + b\nprint(add(3, 4))", capsys) == "7"
+
+
+# ── Conditions ────────────────────────────────────────────────────────────────
+
+def test_if_vrai(capsys):
+    assert out("if(true) { print(1) }", capsys) == "1"
+
+
+def test_if_faux(capsys):
+    assert out("if(false) { print(1) } else { print(0) }", capsys) == "0"
+
+
+def test_if_elif(capsys):
+    code = "var n = 5\nif(n > 10) { print(\"grand\") } elif(n == 5) { print(\"cinq\") } else { print(\"autre\") }"
+    assert out(code, capsys) == "cinq"
+
+
+def test_comparaison_egalite(capsys):
+    assert out("print(3 == 3)", capsys) == "true"
+
+
+def test_comparaison_inegalite(capsys):
+    assert out("print(3 != 4)", capsys) == "true"
+
+
+# ── Boucles ───────────────────────────────────────────────────────────────────
+
+def test_while(capsys):
+    code = "var i = 0\nwhile(i < 3) { print(i)\ni += 1 }"
+    lines = out(code, capsys).split("\n")
+    assert lines == ["0", "1", "2"]
+
+
+def test_for_cstyle(capsys):
+    code = "for(var i: int = 0; i < 3; i += 1) { print(i) }"
+    lines = out(code, capsys).split("\n")
+    assert lines == ["0", "1", "2"]
+
+
+def test_for_each(capsys):
+    code = "var nums: int[] = [1, 2, 3]\nfor(n in nums) { print(n) }"
+    lines = out(code, capsys).split("\n")
+    assert lines == ["1", "2", "3"]
+
+
+def test_break(capsys):
+    code = "var i = 0\nwhile(i < 10) { if(i == 3) { break }\nprint(i)\ni += 1 }"
+    lines = out(code, capsys).split("\n")
+    assert "3" not in lines
+    assert lines[-1] == "2"
+
+
+# ── Classes ───────────────────────────────────────────────────────────────────
+
+def test_class_instanciation(capsys):
+    code = """
+class Point {
+    var x: int
+    var y: int
+    fun __construct(px: int, py: int) {
+        this.x = px
+        this.y = py
+    }
+    fun afficher(): string {
+        return "(" + this.x + ", " + this.y + ")"
+    }
+}
+var p = new Point(3, 4)
+print(p.afficher())
+"""
+    assert out(code, capsys) == "(3, 4)"
+
+
+def test_class_heritage(capsys):
+    code = """
+class Animal {
+    var nom: string
+    fun __construct(n: string) { this.nom = n }
+    fun parler(): string { return this.nom + " parle" }
+}
+class Chien extends Animal {
+    override fun parler(): string { return this.nom + " aboie" }
+}
+var rex = new Chien("Rex")
+print(rex.parler())
+"""
+    assert out(code, capsys) == "Rex aboie"
+
+
+# ── Modules natifs ────────────────────────────────────────────────────────────
+
+def test_math_sqrt(capsys):
+    assert out("inject Math\nprint(Math.sqrt(16))", capsys) == "4.0"
+
+
+def test_math_abs(capsys):
+    assert out("inject Math\nprint(Math.abs(-7))", capsys) == "7"
+
+
+def test_string_upper(capsys):
+    assert out('inject String\nprint(String.upper("hello"))', capsys) == "HELLO"
+
+
+def test_string_lower(capsys):
+    assert out('inject String\nprint(String.lower("MONDE"))', capsys) == "monde"
+
+
+def test_string_length(capsys):
+    assert out('inject String\nprint(String.length("okp"))', capsys) == "3"
+
+
+# ── Gestion d'erreurs ─────────────────────────────────────────────────────────
+
+def test_variable_inconnue():
+    with pytest.raises(Exception):
+        run("print(variableInexistante)")
+
+
+def test_division_par_zero():
+    with pytest.raises(Exception):
+        run("print(1 / 0)")
+
+
+def test_try_catch(capsys):
+    code = """
+try {
+    throw "Erreur test"
+} catch(e) {
+    print("Attrapé")
+}
+"""
+    assert out(code, capsys) == "Attrapé"

oktopios-0.0.1/tests/test_lexer.py

@@ -0,0 +1,194 @@
+"""
+test_lexer.py — Tests unitaires du lexeur Oktopios.
+"""
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "vm"))
+
+import pytest
+from lexer import tokenize
+from token_type import TokenType
+
+
+def tok(code):
+    return list(tokenize(code))
+
+
+# ── Primitives ────────────────────────────────────────────────────────────────
+
+def test_entier():
+    tokens = tok("42")
+    assert tokens[0].type == TokenType.NUMBER
+    assert tokens[0].value == 42
+
+
+def test_float():
+    tokens = tok("3.14")
+    assert tokens[0].type == TokenType.NUMBER
+    assert abs(tokens[0].value - 3.14) < 1e-9
+
+
+def test_string():
+    tokens = tok('"Bonjour"')
+    assert tokens[0].type == TokenType.STR
+    assert tokens[0].value == "Bonjour"
+
+
+def test_booleen_true():
+    tokens = tok("true")
+    assert tokens[0].type == TokenType.BOOLVAL
+    assert tokens[0].value == "true"
+
+
+def test_booleen_false():
+    tokens = tok("false")
+    assert tokens[0].type == TokenType.BOOLVAL
+
+
+# ── Mots-clés ─────────────────────────────────────────────────────────────────
+
+def test_keyword_var():
+    tokens = tok("var")
+    assert tokens[0].type == TokenType.VAR
+
+
+def test_keyword_val():
+    tokens = tok("val")
+    assert tokens[0].type == TokenType.VAL
+
+
+def test_keyword_fun():
+    tokens = tok("fun")
+    assert tokens[0].type == TokenType.FUN
+
+
+def test_keyword_if():
+    tokens = tok("if")
+    assert tokens[0].type == TokenType.IF
+
+
+def test_keyword_return():
+    tokens = tok("return")
+    assert tokens[0].type == TokenType.RETURN
+
+
+def test_keyword_class():
+    tokens = tok("class")
+    assert tokens[0].type == TokenType.CLASS
+
+
+def test_keyword_loop():
+    tokens = tok("loop")
+    assert tokens[0].type == TokenType.LOOP
+
+
+def test_keyword_for():
+    tokens = tok("for")
+    assert tokens[0].type == TokenType.FOR
+
+
+def test_keyword_while():
+    tokens = tok("while")
+    assert tokens[0].type == TokenType.WHILE
+
+
+def test_keyword_lambda():
+    tokens = tok("lambda")
+    assert tokens[0].type == TokenType.LAMBDA
+
+
+def test_keyword_inject():
+    tokens = tok("inject")
+    assert tokens[0].type == TokenType.INJECT
+
+
+def test_keyword_enum():
+    tokens = tok("enum")
+    assert tokens[0].type == TokenType.ENUM
+
+
+# ── Opérateurs ────────────────────────────────────────────────────────────────
+
+def test_op_plus():
+    tokens = tok("+")
+    assert tokens[0].type == TokenType.PLUS
+
+
+def test_op_minus():
+    tokens = tok("-")
+    assert tokens[0].type == TokenType.MINUS
+
+
+def test_op_eqeq():
+    tokens = tok("==")
+    assert tokens[0].type == TokenType.EQEQ
+
+
+def test_op_neq():
+    tokens = tok("!=")
+    assert tokens[0].type == TokenType.NEQ
+
+
+def test_op_lte():
+    tokens = tok("<=")
+    assert tokens[0].type == TokenType.LTE
+
+
+def test_op_gte():
+    tokens = tok(">=")
+    assert tokens[0].type == TokenType.GTE
+
+
+def test_op_pluseq():
+    tokens = tok("+=")
+    assert tokens[0].type == TokenType.PLUSEQ
+
+
+# ── Positions (ligne / colonne) ────────────────────────────────────────────────
+
+def test_position_ligne():
+    tokens = tok("var x = 1\nvar y = 2")
+    # 'var' de la 2e ligne
+    y_tok = next(t for t in tokens if t.value == "y")
+    assert y_tok.line == 2
+
+
+def test_position_colonne():
+    tokens = tok("var x = 42")
+    x_tok = next(t for t in tokens if t.value == "x")
+    assert x_tok.column == 4
+
+
+# ── Commentaires ignorés ──────────────────────────────────────────────────────
+
+def test_commentaire_ignore():
+    tokens = tok("// ceci est un commentaire\nvar x = 1")
+    types = [t.type for t in tokens]
+    assert TokenType.VAR in types
+    # Aucun token de type commentaire
+    assert all(t.type != TokenType.EOF or True for t in tokens)
+
+
+# ── Séquences complexes ───────────────────────────────────────────────────────
+
+def test_sequence_declaration():
+    tokens = tok("var age: int = 25")
+    types = [t.type for t in tokens[:-1]]  # sans EOF
+    assert TokenType.VAR in types
+    assert TokenType.INT in types
+    assert TokenType.NUMBER in types
+
+
+def test_not_in_fusion():
+    """'not in' doit être fusionné en un seul token NOT_IN."""
+    tokens = tok("x not in liste")
+    assert any(t.type == TokenType.NOT_IN for t in tokens)
+
+
+def test_eof_present():
+    tokens = tok("42")
+    assert tokens[-1].type == TokenType.EOF
+
+
+def test_caractere_inattendu():
+    with pytest.raises((SyntaxError, Exception)):
+        tok("var x = @")

oktopios-0.0.1/tests/test_parser.py

@@ -0,0 +1,200 @@
+"""
+test_parser.py — Tests unitaires du parseur Oktopios.
+"""
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "vm"))
+
+import pytest
+from lexer import tokenize
+from parser import Parser
+from ast_nodes import (
+    Program, VarDecl, FunDecl, ClassDeclaration,
+    IfStmt, WhileStmt, ForEachStmt, BlockStmt,
+    ReturnStmt, PrintStmt, Literal, Variable, BinaryOp, FuncCall
+)
+
+
+def parse(code):
+    tokens = list(tokenize(code))
+    return Parser(tokens).parse()
+
+
+# ── Programme vide ────────────────────────────────────────────────────────────
+
+def test_programme_vide():
+    ast = parse("")
+    assert isinstance(ast, Program)
+    assert ast.body == []
+
+
+# ── Déclarations de variables ─────────────────────────────────────────────────
+
+def test_var_int():
+    ast = parse("var x: int = 42")
+    node = ast.body[0]
+    assert isinstance(node, VarDecl)
+    assert node.name == "x"
+
+
+def test_val_string():
+    ast = parse('val msg: string = "Oktopios"')
+    node = ast.body[0]
+    assert isinstance(node, VarDecl)
+    assert node.name == "msg"
+    assert node.is_constant is True
+
+
+def test_var_sans_type():
+    ast = parse("var x = 10")
+    node = ast.body[0]
+    assert isinstance(node, VarDecl)
+
+
+# ── Fonctions ─────────────────────────────────────────────────────────────────
+
+def test_fun_simple():
+    ast = parse("fun saluer() { }")
+    node = ast.body[0]
+    assert isinstance(node, FunDecl)
+    assert node.name == "saluer"
+
+
+def test_fun_avec_params():
+    ast = parse("fun add(a: int, b: int): int { return a + b }")
+    node = ast.body[0]
+    assert isinstance(node, FunDecl)
+    assert len(node.params) == 2
+    assert node.params[0][0] == "a"
+    assert node.params[1][0] == "b"
+
+
+def test_fun_return_type():
+    ast = parse("fun get(): string { return \"ok\" }")
+    node = ast.body[0]
+    assert isinstance(node, FunDecl)
+    assert node.return_type == "string"
+
+
+def test_fun_surcharge():
+    ast = parse("""
+        fun f(a: int): int { return a }
+        fun f(a: int, b: int): int { return a + b }
+    """)
+    funs = [n for n in ast.body if isinstance(n, FunDecl)]
+    assert len(funs) == 2
+
+
+# ── Conditions ────────────────────────────────────────────────────────────────
+
+def test_if_simple():
+    ast = parse("if(x > 0) { print(x) }")
+    node = ast.body[0]
+    assert isinstance(node, IfStmt)
+
+
+def test_if_else():
+    ast = parse("if(x > 0) { print(1) } else { print(0) }")
+    node = ast.body[0]
+    assert isinstance(node, IfStmt)
+    assert node.else_body is not None
+
+
+def test_if_elif_else():
+    ast = parse("if(x > 0) { print(1) } elif(x == 0) { print(0) } else { print(-1) }")
+    node = ast.body[0]
+    assert isinstance(node, IfStmt)
+
+
+# ── Boucles ───────────────────────────────────────────────────────────────────
+
+def test_while():
+    ast = parse("while(i < 10) { i += 1 }")
+    # WhileStmt peut être wrappé dans un BlockStmt
+    node = ast.body[0]
+    assert isinstance(node, WhileStmt)
+
+
+def test_for_each():
+    ast = parse("for(n in nums) { print(n) }")
+    node = ast.body[0]
+    assert isinstance(node, ForEachStmt)
+    assert node.var_name == "n"
+
+
+def test_for_cstyle():
+    ast = parse("for(var i: int = 0; i < 3; i += 1) { print(i) }")
+    # Produit un BlockStmt(VarDecl, WhileStmt)
+    node = ast.body[0]
+    assert isinstance(node, (BlockStmt, WhileStmt))
+
+
+# ── Classes ───────────────────────────────────────────────────────────────────
+
+def test_class_vide():
+    ast = parse("class Animal { }")
+    node = ast.body[0]
+    assert isinstance(node, ClassDeclaration)
+    assert node.name == "Animal"
+
+
+def test_class_avec_methode():
+    ast = parse("""
+        class Chat {
+            fun parler(): string {
+                return "Miaou"
+            }
+        }
+    """)
+    node = ast.body[0]
+    assert isinstance(node, ClassDeclaration)
+
+
+def test_class_extends():
+    ast = parse("class Chien extends Animal { }")
+    node = ast.body[0]
+    assert isinstance(node, ClassDeclaration)
+    assert node.superclass is not None
+
+
+# ── Expressions ───────────────────────────────────────────────────────────────
+
+def test_binop_addition():
+    ast = parse("print(1 + 2)")
+    # Ne doit pas lever d'exception
+
+
+def test_binop_precedence():
+    ast = parse("print(2 + 3 * 4)")
+    # 2 + (3*4) = 14, pas (2+3)*4 = 20
+
+
+def test_appel_fonction():
+    ast = parse("add(1, 2)")
+    node = ast.body[0]
+    # FuncCall ou ExpressionStmt wrappant FuncCall
+    assert node is not None
+
+
+def test_acces_attribut():
+    ast = parse("obj.nom")
+
+
+def test_new():
+    ast = parse("var a = new Animal()")
+
+
+# ── Erreurs de syntaxe ────────────────────────────────────────────────────────
+
+def test_accolade_manquante():
+    with pytest.raises(Exception):
+        parse("fun f() { ")
+
+
+def test_paren_non_fermee():
+    with pytest.raises(Exception):
+        parse("print(42")
+
+
+def test_expression_invalide():
+    with pytest.raises(Exception):
+        parse("var x = ")