node gir

nodo-gir

Node-GIR es Node.js Bindings a la introspección de gobectar que es posible hacer llamadas automáticas y dinámicas a cualquier biblioteca que tenga anotaciones GI instaladas. Esto incluye la mayoría de las bibliotecas del proyecto GNOME.

Esto permitirá escribir un sistema de escritorio GNOME completamente desde el nodo mucho en la forma en que se hace hoy con semillas, GJS o PYGTK. También permite usar bibliotecas GNOME en aplicaciones Node.js. Con él también puede escribir las partes intensivas en rendimiento de sus aplicaciones en Vala y llamarlas desde Node.js y otros idiomas.

Instalación

Necesita que se instale la biblioteca de introspección de gobect. En un sistema de Debian, esto sería manejado por:

 $ sudo apt-get install libgirepository1.0-dev

Entonces simplemente construya el nodo-gir con:

 $ npm install gir

Pruebas

El repositorio de nodo-gir viene con un conjunto de pruebas que utilizan la biblioteca Midgard2 para probar. También necesita eso instalado y luego ejecutar:

 $ npm test

Travis se utiliza para la integración continua:

Arquitectura

El siguiente gráfico muestra todas las piezas y cómo funcionan juntas. La única parte faltante son los enlaces de nodo a Libgirepository. De ahí este proyecto.

 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      |
                           +------------------+

¿Por qué no usar semillas o GJS?

Porque son agradables, pero no lo que estoy buscando. El nodo es realmente popular y sería bueno poder usarlo para herramientas y aplicaciones de escritorio.

Notas de implementación

Aquí hay algunos enlaces y notas mientras trato de descubrir cómo hacer esto.

• https://wiki.gnome.org/projects/gobjectintrospection/howtowritealanguaginding
• https://developer.gnome.org/gi/unstable/

Ideas API

Algunas de estas ideas irán en este encuadernación y otras irán en envoltorios agradables que lo usan. Sabré más a medida que avanzamos.

• Use camelCase para métodos que están destinados a ver JavaScripty.
• Use .on(name, callback) para adjuntar señales.
• Mantenga el mismo estilo de constructor utilizado por las semillas y los GJS
• Haga que el sistema del módulo sea lo más parecido a un nodo posible.

Cosas que funcionan

• Todas las clases se crean
• Las clases se heredan
• Se heredan los métodos de interfaz
• Una clase tiene listas de todas sus propiedades, métodos, señales, VFuncs y campos
• Las estructuras C se propagan como objetos (los campos son propiedades)
• Se pueden llamar tanto a los métodos como al método estático
• Puedes crear una clase
• Se pueden llamar a las funciones (pero no funciona tan bien con los argumentos 'fuera' que deben establecerse como valor devuelto)
• Gerror se propaga como excepción genérica
• Los valores de la propiedad se pueden establecer/obtener
• Los eventos se pueden ver
• Flags, enums, etc. están establecidos

Cosas que no funcionan (correctas)

• La conversión entre un valor de V8 y un gvalue/gargumento es Veeeery Buggy (pero todo lo necesita, por lo que la mayoría de las cosas son erróneas)
• No hay apoyo para Libev/Libuv; Glib está usando sus propias cosas (gst.main ())
• No hay una buena manera de eliminar un objeto (la gestión de la memoria apesta en absoluto)
• types/function.cc need a rewrite
• GError should be propagated as derived classes depending on GError domain