runmany
1.0.0
Intro | Installation | Utilisation | Syntaxe | Paramètres | À propos
Un outil pour exécuter de nombreux programmes écrits dans de nombreuses langues à partir d'un seul fichier.
Normalement, pour pratiquer plusieurs langages de programmation à la fois, vous avez besoin de plusieurs fichiers ou de plusieurs projets, peut-être plusieurs IDE. Runmany est un outil qui vous permet d'écrire plusieurs programmes dans le même fichier en utilisant tous les langages de programmation que vous souhaitez, puis les exécuter tous en même temps.
Runmany utilise ".many" comme extension de fichier, donc par exemple, si un fichier appelé simple.many a le contenu suivant:
Python:
print("Hi")
JavaScript:
console.log("Hi")
C:
#include <stdio.h>
int main() {
printf("Hin");
return 0;
}
Ensuite, faire runmany simple.many in Terminal produira cette sortie organisée de l'exécution des programmes Python, JavaScript et C dans:
************************************************************
1. Python
-------------------- output from line 1 --------------------
Hi
************************************************************
2. JavaScript
-------------------- output from line 4 --------------------
Hi
************************************************************
3. C
-------------------- output from line 7 --------------------
Hi
************************************************************
3/3 programs successfully run!
3/3 had the exact same stdout!
************************************************************
Argv et STDIN peuvent également être spécifiés dans le fichier .Mais.
En général, Runmany peut être utilisé pour:
Global Runmany est un outil utile pour tous ceux qui souhaitent jouer avec plusieurs langages de programmation à la fois.
Assurez-vous que Python version 3.6 ou supérieure à l'installation, puis exécutez
pip install runmany
dans Terminal pour installer le dernier package Python Runmany de PYPI. Ensuite, runmany <filename> devrait fonctionner pour exécuter des fichiers. Voir plus de façons de courir dans l'utilisation.
Runmany fonctionne mieux dans VScode avec l'extension VSCODE Runmany Companion qui fournit une mise en évidence de la syntaxe pour les fichiers .Many et des moyens rapides de les exécuter. Installez l'extension gratuitement sur le marché ou en fonctionnant:
code --install-extension discretegames.runmany
Vous avez également besoin des langages de programmation que vous souhaitez que Runmany s'exécute sur votre ordinateur, car Runmany utilise leurs interprètes / compilateurs dans les coulisses pour exécuter des programmes.
Runmany a une prise en charge intégrée pour les langues suivantes:
Ada, Bash, Batch, C, C #, C ++, Dart, Fortran, Go, Groovy, Haskell, Java, JavaScript, Julia, Kotlin, Lisp, Lua, MIPS, Pascal, Perl, Php, Powershell, Print, Python, Python 2, R, Racket, Ruby, Rust, Scala, Typecript, Typecrip
Ce qui signifie que si vous avez déjà une de ces langues installée, il y a de fortes chances que cela fonctionne automatiquement dans Runmany.
L'extension VScode Runmany fournit une mise en évidence de la syntaxe pour toutes ces langues plus quelques autres.
Il existe des moyens d'ajouter des langues personnalisées et de modifier le comportement des langues intégrées, et même de les rendre différentes sur différents systèmes d'exploitation. Pour plus d'informations, voir la personnalisation des langues.
Notez que Print est un langage utilitaire qui imprime simplement le contenu du code à STDOUT, et MIPS s'attend à ce que mars.jar soit dans le répertoire de travail actuel.
Si pip install runmany n'a pas fonctionné, essayez pip3 install runmany ou python -m pip install runmany ou python3 -m pip install runmany .
Sur Windows, si rien ne fonctionne, vous devrez peut-être vous assurer que les répertoires d'installation et de scripts Python sont dans votre variable d'environnement de chemin, puis redémarrez votre terminal et réessayez.
Runmany a été fabriqué dans Python 3.9 sur Windows et a été soigneusement testé sur les versions Python 3.6, 3.7, 3.8, 3.9 et 3.10 sur Windows. Il devrait également fonctionner bien sur Linux et MacOS, mais a été moins largement testé sur les systèmes d'exploitation, en particulier en ce qui concerne les commandes qui exécutent les interprètes / compilateurs d'autres langages de programmation.
Runmany est désormais dans la version 2 avec une syntaxe de fichiers. Demany améliorée et plus de paramètres. L'ancienne version 1.0.3 est toujours disponible sur PYPI.
Pour exécuter un fichier Runmany nommé myfile.many , utilisez la commande Terminal:
runmany myfile.many
Il existe également des arguments facultatifs pour obtenir de l'aide et spécifier les paramètres et les fichiers de sortie:
runmany [-h --help] [-s --settings <settings-file>] [-o --outfile <output-file>] <input-file>
<input-file> est le fichier .Les.<settings-file> est le fichier .json facultatif qui définit la façon dont les langues sont exécutées et comment la sortie est formatée.<output-file> est le fichier facultatif auquel envoyer la sortie. Lorsqu'il est omis, la sortie va à Stdout. Par exemple, la commande pour exécuter myfile.many avec des paramètres mysettings.json et envoyer une sortie à myoutput.txt serait:
runmany -s mysettings.json -o myoutput.txt myfile.many
Lorsqu'un fichier de paramètres est fourni sur la ligne de commande, toutes les sections de paramètres intégrées dans le fichier d'entrée sont ignorées. Si aucun n'est présent, ni pour les paramètres manquants, default_settings.json est utilisé comme repli. Voir plus d'informations dans les paramètres.
Pour quelques exemples de fichiers .Many et leur sortie vérifie le dossier d'exemples sur GitHub ou le référentiel de challenges, où divers défis de code pour des sites comme le projet Euler sont résolus dans de nombreuses langues à la fois.
L'extension .Many pour les fichiers Runmany n'est pas requise mais recommandée pour plus de clarté.
Runmany peut être importé et utilisé à partir de Python comme suit:
from runmany import runmany , runmanys
# Run to stdout
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' ) # settings JSON is always optional
# Run to output file
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' , 'path/to/myoutput.txt' )
# Run to file object
with open ( 'path/to/myoutput.txt' , 'w' ) as output_file :
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' , output_file )
# Run to string
output_string = runmanys ( 'path/to/myfile.many' , 'path/to/mysettings.json' )
print ( output_string ) Dans les fonctions runmany.runmany et runmany.runmanys , from_string=True fera interpréter l'argument de fichier .Many comme une chaîne au lieu d'un chemin de fichier, et l'argument JSON des paramètres peut être donné comme un chemin vers le fichier .json ou un dictionnaire Python de type JSON, ou None pour ne fournir aucun paramètre. Comme pour l'exécution à partir de la ligne de commande, la fourniture de paramètres ici signifie que tous les paramètres intégrés dans le fichier .many sont ignorés.
La fonction runmany.cmdline , qui prend une liste des arguments de ligne de commande, est également présente comme une alternative à l'utilisation directement de la ligne de commande.
Le format de fichier .many est ce que Runmany attend lorsqu'on lui donne un fichier.
Principalement, un fichier .Lomy se compose de sections qui contiennent chacune un ou plusieurs extraits. Une section commence par une ligne d'en-tête non inférieure telle que Python: ou Stdin for Python: alors le contenu du premier extrait est ce qui apparaît après le côlon et sur les lignes en retrait ci-dessous. Des extraits supplémentaires peuvent être ajoutés à la section avec un en-tête non inférieur Also: et une section se termine lorsqu'un nouveau démarre ou une End. ou la fin du fichier est atteinte.
Un fichier .Many s'exécute de haut en bas, exécutant des sections et des extraits dans l'ordre où ils sont rencontrés. Notamment, un fichier .Many s'exécutera, qu'il ait ou non des erreurs de syntaxe. Toute syntaxe non valide sera ignorée et mentionnée dans un message d'erreur.
Dans l'exemple .Lomy fichier ci-dessous, la section Stdin for Python: a deux extraits, bar et baz , et ils deviennent l'entrée standard pour le programme Python dans la section Python: qui a un print('foo' + input()) . L'exécution de ce fichier exécute le programme Python deux fois, une fois pour bar et une fois pour baz , donnant les sorties respectives foobar et foobaz .
Stdin for Python:
bar
Also:
baz
End.
Python:
print('foo' + input())
End.
Lisez la suite pour des détails sur toutes les syntaxes de fichiers.
%% En tant que premier caractères non-blancs d'une ligne, fait un commentaire jusqu'à la fin de cette ligne.
%% this is a comment
Python: %% this is not a comment
%% this is a comment
print(1) %% this is not a comment
Il n'y a pas de commentaires de blocs, bien que le démarrage et l'arrêt soient proches de la fonctionnalité.
Comme mentionné, un fichier .Many se compose de sections qui commencent par un en-tête et contiennent des extraits. Il existe quatre types de sections:
<language>: ou <language1>, <language2>, ...:Argv: ou Argv for <language1>, <language2>, ...:Stdin: ou Stdin for <language1>, <language2>, ...:Settings: Tous, sauf la section Paramètres, peuvent avoir une liste séparée par des virgules des langues auxquelles elle s'applique dans l'en-tête. Ces langues, une fois dépouillées de l'espace, doivent correspondre aux touches "name" des langues dans les paramètres JSON, mais ne sont pas sensibles à la casse. (Les mots clés comme "argv" et "stdin" sont sensibles à la casse. Les langages personnalisés ne doivent pas utiliser les mots clés Runmany comme des noms ni contenir les caractères ,:%!@ .)
L'en-tête Also: est utilisé pour ajouter des extraits à une section et End. peut éventuellement être utilisé pour mettre fin à une section.
Le contenu d'un extrait est le texte après n'importe quel espace blanc après le côlon ( : dans l'en-tête de l'extrait, plus toutes les lignes ci-dessous qui sont en retrait avec une seule onglet ou 4 espaces (avec ces retraits supprimés), jusqu'à la tête ou End. ou fin du fichier.
Donc cette section de code
Python: import math
print(math.pi)
Also: print('pie')
print('cake')
A deux extraits dont le contenu est:
import math
print ( math . pi ) print ( 'pie' )
print ( 'cake' )Les lignes vides au-dessus ou en dessous des sections sont uniquement pour la lisibilité et non requises. Le code non composé en dehors des sections n'est pas valide.
Une section de code commence tout de suite avec une liste de langues séparée par des virgules et son contenu d'extraits est les programmes à exécuter dans ces langues.
Une langue dans la liste séparée des virgules est presque toujours suffisante à moins que vous écriviez des polyglouts,
JavaScript:
console.log('Some code that will be run in JavaScript.')
Python, Python 2:
print('Some code that will be run in Python 3 then Python 2.')
Also:
print('Some more code that will be run in Python 3 then Python 2.')
Also: les en-têtes d'extraits dans les sections de code sont des raccourcis pour répéter l'en-tête de la section.
Argv est le vecteur d'argument, alias les arguments de ligne de commande envoyés aux programmes.
Une section Argv peut soit démarrer Argv: pour s'appliquer à toutes les langues, soit Argv for <language1>, <language2>, ...: pour s'appliquer aux langues dans la liste séparée par les virgules. Quoi qu'il en soit, l'écrasement de tout jeu ARGV précédent pour ces langues.
Chaque extrait d'une section Argv est un argv distinct qui sera envoyé à son tour aux programmes des langues à laquelle s'applique la section. Cela facilite le test de nombreux argvs à la fois.
Argv: argv sent to all languages
Argv for Python: 1
Also: 2
Also: 3
Python:
import sys
print(sys.argv[1])
Ce code .Unhyy exécutera le programme Python trois fois avec Argv 1 puis 2 puis 3 .
Pour que Argv travaille, l'espace réservé $argv doit être correctement placé dans la commande de la langue.
Presque exactement comme une section ARGV, mais pour les utilisateurs standard des flux d'entrée, tapez normalement le texte.
Une section STDIN peut soit démarrer Stdin: pour s'appliquer à toutes les langues, soit Stdin for <language1>, <language2>, ...: pour s'appliquer aux langues dans la liste séparée par les virgules. Quoi qu'il en soit, l'écrasement de tout ensemble de stdin précédent pour ces langues.
Chaque extrait d'une section STDIN est un stdin distinct qui sera envoyé à son tour aux programmes des langues auxquels la section s'applique. Cela facilite le test de nombreux stdins à la fois.
Stdin: stdin sent to all languages
Stdin for Python: A
Also: B
Also: C
Python:
print(input())
Ce code .Unhyy exécutera le programme Python trois fois avec stdin A puis B puis C .
Lorsque plusieurs argvs et stdins s'appliquent à une langue, toutes les combinaisons possibles de chaque argv et de chaque stdin sont envoyées à des programmes de cette langue.
Une section Paramètres démarre avec Settings: et permet d'intégrer un JSON paramètres dans un fichier .Many, qui est utilisé jusqu'à ce qu'une autre section de paramètres soit rencontrée.
Ces paramètres intégrés ne sont utilisés que lorsque les paramètres n'étaient pas spécifiquement fournis lorsque Runmany a été appelé. Tous les paramètres manquants par défaut par défaut leurs valeurs dans default_settings.json.
Settings:
{ "show_code": true }
Python:
print('this Python code will now be shown as part of the output')
Une chaîne JSON du chemin vers un fichier de paramètres peut également être utilisée, comme Settings: "path/to/mysettings.json" .
Also: les en-têtes d'extraits dans les sections de paramètres sont des raccourcis pour répéter l'en-tête de la section. Ils ne servent donc pas beaucoup de fins car ils écrasent immédiatement les paramètres précédents.
Put !! Au début d'un en-tête de section désactive toute la section et tous ses extraits.
! Au début d'un en-tête d'extrait, désactive cet extrait.
!!Python:
print('this is disabled')
Also:
print('this is also disabled')
!Python:
print('this is disabled')
Also:
print('this is not disabled')
!Also:
print('this is disabled')
Si des en-têtes de section commencent par @@ , seules ces sections sont exécutées, similaire à une case à cocher "solo" dans le logiciel d'édition audio / vidéo.
Si des en-têtes d'extraits dans une section commencent par @ , seuls les extraits sont exécutés lorsque la section s'exécute.
@@@Python:
print('this is run')
Also:
print('this is not run')
@Also:
print('this is run')
Python:
print('this is not run')
@Also:
print('this is also not run')
Notez comment la première ligne a trois @@@ , deux pour en solo la section et une autre pour en solo son premier extrait.
Tout avant le dernier START: au début d'une ligne par lui-même dans un fichier .many est ignoré.
Tout après le premier STOP. Au début d'une ligne en soi dans un fichier .Many est ignoré.
Ainsi, seule la section JavaScript de ce fichier .Lany est exécutée:
Python: print('unseen')
START:
JavaScript: console.log('seen')
STOP.
Python: print('unseen')
Il ne devrait y avoir qu'un seul START: et un STOP. Dans un fichier .Many.
Le paramètre de Runmany est défini par un fichier JSON qui peut être fourni lorsque Runmany est appelé ou directement intégré dans un fichier .many.
Les paramètres JSON définissent les langages que Runmany peut exécuter et comment il les exécutera. Il définit également comment la sortie Runmany sera formatée.
Le fichier default_settings.json détient les valeurs par défaut pour tous les paramètres. Ces valeurs par défaut sont automatiquement utilisées si elles ne sont pas présentes dans un paramètres fournis ou intégrés JSON.
La plupart des paramètres sont des drapeaux ou des valeurs simples qui peuvent être définis dans les paramètres de base JSON Object pour les appliquer globalement (voir la liste des paramètres), mais quatre touches spéciales dans le JSON sont utilisées pour personnaliser les langages que Runmany peut exécuter ou pour ajouter plus de langues. Ce sont "languages" , "languages_windows" , "languages_linux" et "languages_mac" ( "languages_<os>" seront utilisés pour se référer aux trois derniers). Ce sont des tableaux d'objets JSON à un niveau unique qui spécifient les paramètres de la langue qui correspond à la clé "name" de l'objet.
Le tableau "languages_<os>" qui correspond au système d'exploitation système a la priorité la plus élevée lors de la détermination des paramètres d'une langue, suivis du tableau "languages" , suivi des tableaux "supplied_languages_<os>" et "supplied_languages" intégrés. (Ces tableaux "supplied_languages..." ne doivent jamais être définis dans vos paramètres JSON.) Les langues utilisent les paramètres de l'objet JSON de base en tant que repli final.
Par exemple, les paramètres suivants JSON définissent le paramètre "show_code" (qui est faux par défaut) à TRUE pour toutes les langues, à l'exception de Python et Python 2. Il crée également une nouvelle langue "Python 3.10" qui peut être utilisée dans un en-tête de section de fichiers .Many sur Windows.
{
"show_code" : true ,
"languages" : [
{ "name" : " Python " , "show_code" : false },
{ "name" : " Python 2 " , "show_code" : false }
],
"languages_windows" : [
{ "name" : " Python 3.10 " , "extension" : " .py " , "command" : " py -3.10 " }
]
} La touche "name" est requise pour chaque objet dans un tableau de langues, et les touches "command" et "extension" doivent toujours être fournies pour de nouvelles langues personnalisées. Cependant, tous les paramètres n'ont pas de sens de s'appliquer sur une base permanente. Par exemple, "show_equal" s'applique à l'exécution du fichier .many dans son ensemble, donc cela n'a de sens que dans l'objet JSON de base.
Tous les paramètres décrits et s'ils peuvent être remplacés ou non sur une base permanente dans les "languages" et "languages_<os>" Objets Array:
| Clé JSON | Taper | Défaut | Surclassable | Description |
|---|---|---|---|---|
"command" | chaîne | "echo NOCOMMAND" | Oui | La commande console pour exécuter une langue, suivant le format de commande. |
"extension" | chaîne | "" | Oui | L'extension de fichier d'une langue, y compris le point. |
"timeout" | flotter | 10.0 | Oui | La limite de temps de chaque programme en secondes, ou null pour aucune limite de temps. |
"runs" | int | 1 | Oui | Le nombre de fois que chaque programme est exécuté. Seule la sortie de la dernière exécution est affichée. |
"stderr" | chaîne | "smart" | Oui | "yes" / true pour combiner le programme Stderr avec STDOUT. "no" / false pour masquer le programme stderr. "smart" / null pour afficher STDERR uniquement lorsque les programmes ont des codes de sortie non nuls. |
"spacing" | int | 1 | Oui | Le nombre de lignes vides à ajouter après chaque exécution. |
"newline" | chaîne | "n" | Oui | Ce que les Newlines sont remplacés par le contenu de l'extrait de code, argv et stdin. Ou null pour la valeur par défaut du système d'exploitation. |
"tab" | chaîne | "t" | Oui | Ce que le caractère d'onglet est remplacé par le contenu de l'extrait de code, argv et stdin. |
"cwd" | chaîne | null | Oui | Le répertoire de travail actuel pour exécuter des programmes. Peut être un chemin relatif. Utilisez null ou "." pour aucun changement dans le répertoire de travail actuel. |
"minimalist" | bool | false | Non | L'avis afficher toutes les sorties dans un format minimal où les diviseurs, le code, l'argv et le stdin ne sont pas affichés. |
"run_blanks" | bool | false | Non | Que ce soit des extraits vierges qui constituent uniquement des espaces sont exécutés ou ignorés. |
"show_time" | bool | false | Oui | Si le temps d'exécution est affiché. Utile pour les tests de performances lorsqu'ils sont combinés avec "runs" . |
"show_command" | bool | false | Oui | Si la commande utilisée pour exécuter chaque programme est affichée. Utile pour le débogage des commandes pour les nouvelles langues. |
"show_code" | bool | false | Oui | Si le code source du programme est affiché. |
"show_argv" | bool | true | Oui | Si l'ARGV pour le programme est montré (lorsqu'il est présent). |
"show_stdin" | bool | true | Oui | Si le stdin pour le programme est affiché (lorsqu'il est présent). |
"show_output" | bool | true | Oui | Si la sortie du programme est indiquée. Cela inclut le stdout, et, selon "stderr" , le stderr. |
"show_runs" | bool | true | Non | Si la liste des courses est affichée. Il s'agit généralement de la majeure partie de la sortie. |
"show_stats" | bool | true | Non | Que le succès et le nombre d'échecs soient montrés après tout. |
"show_equal" | bool | true | Non | Si les stdouts correspondants sont comparés et regroupés après tout. |
"show_errors" | bool | true | Non | Si les erreurs de runmany comme ` |
"strip_argv" | chaîne | "smart" | Non | "yes" / true pour retirer le contenu de l'extrait de l'espace blanc dirigeant et traînant. "no" / false pour garder le contenu de l'extrait tel quel. "smart" / null pour rejoindre toutes les lignes de l'extrait avec des espaces comme s'ils étaient sur une seule ligne. |
"strip_stdin" | chaîne | "smart" | Non | "yes" / true pour supprimer le début et la fin de l'extrait des lignes Whitespace uniquement. "no" / false pour garder le contenu de l'extrait tel quel. "smart" / null pour faire de même que "yes" / true , mais également ajouter une seule nouvelle ligne. |
"strip_code" | chaîne | "smart" | Oui | "yes" / true pour supprimer le début et la fin de l'extrait des lignes Whitespace uniquement. "no" / false pour garder le contenu de l'extrait tel quel. "smart" / null pour traiter le haut du fichier .Many comme le début de l'extrait de code avec toutes les pièces non pertinentes blanchies afin que les erreurs dans les programmes indiquent les numéros de ligne corrects. |
"strip_output" | chaîne | "no" | Oui | "yes" / true To Strip Program Sortie de l'espace de leader et de fin. "no" / false pour laisser la sortie du programme tel quel. "smart" / null pour supprimer la sortie du programme des lignes de tête et de fin vides. |
Il convient de mentionner que les parties du code, de l'ARGV et du stdin de la sortie de fichier .Lomy sont dépouillées de lignes vides pour garder les choses visuellement propres quelles que soient les valeurs de "strip_code" , "strip_argv" et "strip_stdin" .
La clé "command" d'un objet dans le tableau "languages" ou "languages_<os>" Définit la commande Terminal qui est exécutée pour exécuter cette langue.
Les espaces réservés comme $file et $dir peuvent être utilisés dans une commande pour se référer au fichier temporaire que Runmany crée pour le code de chaque programme qu'il exécute et le répertoire dans lequel le fichier est stocké:
| Espace réservé | Partie de .../dir/file.ext |
|---|---|
$rawdir | .../dir |
$dir | ".../dir" |
$rawfile | .../dir/file.ext |
$file | ".../dir/file.ext" |
$rawbranch | .../dir/file |
$branch | ".../dir/file" |
$name | file.ext |
$stem | file |
$ext | .ext |
$sep | / (OS spécifique) |
$argv | n / a - L'argv est inséré ici |
$code | N / A - Le contenu de l'extrait brut |
Notez que certains espaces réservés sont "cités" et que certains ne le sont pas. Certains systèmes d'exploitation comme Windows peuvent avoir des espaces dans le chemin d'accès aux fichiers temporaires, donc la citation correcte est importante.
Si $ n'est présent nulle part dans la chaîne de commande, $file $argv y est ajouté. Par exemple, la commande python est implicitement python $file $argv .
Vérifiez le tableau "supplied_languages" dans default_settings.json pour plus d'exemples de commandes.
J'ai été conduit à faire du ruissellement par mon désir d'apprendre plus de langages de programmation, combinés à ma gêne que chaque fois que j'essayais, je devais invariablement faire un tout nouveau projet pour cette langue, ou même changer d'ides.
Je prévois de l'utiliser pour pratiquer la résolution des défis du code dans plusieurs langues à partir de sites comme Project Euler.
Découvrez certains de mes autres packages Python.
