node gir

giron de nœud

Node-gir est des liaisons Node.js à Gobject Introspection, ce qui permet de passer des appels automatiques et dynamiques à n'importe quelle bibliothèque qui a des annotations GI installées. Cela inclut la plupart des bibliothèques du projet GNOME.

Cela permettra de scripter un système de bureau Gnome entièrement à partir de nœud dans la façon dont il est fait aujourd'hui avec des semences, des GJS ou des pygtk. Il permet également d'utiliser des bibliothèques GNOME dans les applications Node.js. Avec lui, vous pouvez également écrire les parties à forte intensité de performances de vos applications dans Vala et les appeler à partir de Node.js et d'autres langues.

Installation

Vous avez besoin d'installer la bibliothèque d'introspection Gobject. Sur un système de type Debian, cela serait géré par:

 $ sudo apt-get install libgirepository1.0-dev

Ensuite, construisez simplement le giron de nœud avec:

 $ npm install gir

Essai

Le référentiel de nœuds-gir est livré avec un ensemble de tests qui utilisent la bibliothèque Midgard2 contre laquelle tester. Vous avez également besoin de celui installé, puis exécuté:

 $ npm test

Travis est utilisé pour une intégration continue:

Architecture

Le graphique suivant montre toutes les pièces et comment elles fonctionnent ensemble. La seule partie manquante est les liaisons de nœud à libgirepository. D'où ce projet.

 BUILD TIME:

          +-----------------------------------------------------------+
          |   foo.c                                                   |
          |   foo.h                                                   |
          |                                                           |
          | Library sources, with type annotations                    |
          +-----------------------------------------------------------+
              |                                      |
             gcc                                 g-ir-scanner
              |                                      |
              |                                      V
              |                              +------------------------+
              |                              |    Foo.gir             |
              |                              |                        |
              |                              |    <GI-name>.gir       |
              |                              |                        |
              |                              | XML file               |
              |                              |                        |
              |                              | Invocation information |
              |                              | Required .gir files    |
              |                              | API docs               |
              |                              |                        |
              |                              +------------------------+
              |                                          |
              |                                     g-ir-compiler
              |                                          |
  DEPLOYMENT TIME:                                       |
              |                                          |
              V                                          V
        +-----------------------------+      +---------------------------+
        |   libfoo.so                 |      |    Foo.typelib            |
        |                             |      |                           |
        |                             |      | Binary version of the     |
        |  ELF file                   |      | invocation info and       |
        |                             |      | required .typelib files   |
        |  Machine code, plus         |      +---------------------------+
        | dynamic linkage information |                  A
        | (DWARF debug data, etc)     |                  |
        +-----------------------------+                  |
                     A                                   |
                     |                       +---------------------------+
                     |                       |  libgirepository.so       |
                +-----------+                |                           |
                | libffi.so |                |  Can read typelibs and    |
                |           |                |  present them in a        |
                +-----------+                |  libffi-based way         |
                     A                       |                           |
                     |                       +---------------------------+
                     |                                  A
                     |                                  |
                     |                          +------------+
                     +--------------------------|  node-gir  |
                                                |            |
                                     +--------->+------------+
                                     |
                           +------------------+
                           |      NodeJS      |
                           +------------------+

Pourquoi ne pas utiliser les semences ou les GJ

Parce qu'ils sont gentils, mais pas ce que je recherche. Le nœud est vraiment populaire et ce serait bien de pouvoir l'utiliser pour les outils et les applications de bureau.

Notes de mise en œuvre

Voici quelques liens et notes alors que j'essaie de comprendre comment procéder.

• https://wiki.gnome.org/projects/gobjectIntospection/howtowritealanguagebinding
• https://developer.gnome.org/gi/unstable/

Idées API

Certaines de ces idées iront dans cette reliure et d'autres iront dans de beaux emballages qui l'utiliseront. J'en saurai plus au fur et à mesure que nous progressons.

• Utilisez camelCase pour des méthodes qui sont forcément à paraître javascripty.
• Utilisez .on(name, callback) pour attacher des signaux.
• Gardez le même style de constructeur utilisé par les graines et les GJ
• Rendre le système de module aussi semblable à un nœud que possible.

Des choses qui fonctionnent

• Toutes les classes sont créées
• Les cours sont hérités
• Les méthodes d'interface sont héritées
• Une classe a des listes de toutes ses propriétés, méthodes, signaux, VFUNC et champs
• C Les structures sont propagées en tant qu'objets (les champs sont des propriétés)
• Les méthodes et la méthode statique peuvent être appelées
• Vous pouvez créer une classe
• Les fonctions peuvent être appelées (mais cela ne fonctionne pas si bien avec les arguments «Out» qui doivent être définis en tant que valeur renvoyée)
• Gerror se propage comme exception générique
• Les valeurs de la propriété peuvent être définies / obtenez
• Les événements peuvent être surveillés
• Les drapeaux, les énumérations, etc. sont définis

Les choses qui ne fonctionnent pas (correct)

• La conversion entre une valeur V8 et une gvalue / garguation est un buggy de veeeery (mais tout en a besoin pour que la plupart des choses soient buggy)
• Aucun soutien pour Libev / Libuv; Glib utilise ses propres trucs (gst.main ())
• Il n'y a aucun bon moyen de supprimer un objet (la gestion de la mémoire est nul)
• types / function.cc a besoin d'une réécriture
• Gerror doit être propagé comme des classes dérivées en fonction du domaine Gerror