Yeah, but it's a great way for newcomers to quickly test things out

On November 8, 2017 9:00:33 PM EST, Andrea Giammarchi 
<andrea.giammar...@gmail.com> wrote:
>it's just slower, and the script few KB instead of an npx install each
>time.
>
>I'm doing fine with npm install -g cgjs-about but you feel free to use
>npx
>
>On Wed, Nov 8, 2017 at 10:31 PM, Ben Iofel <iofel...@gmail.com> wrote:
>
>> I didn't expect this to work, but `npx cgjs-about` works fine,
>without
>> having to install cgjs-about.
>>
>> On Wed, Nov 8, 2017 at 5:50 PM, Andrea Giammarchi <
>> andrea.giammar...@gmail.com> wrote:
>>
>>> cgjs-about 0.2.0 is out with `abstract class` and `adbstracts` info
>per
>>> namespace/class
>>>
>>> thanks everybody for the hint!
>>>
>>> On Wed, Nov 8, 2017 at 1:43 PM, Emmanuele Bassi <eba...@gmail.com>
>wrote:
>>>
>>>> If you're parsing the GIR, there's an "abstract" attribute for
>abstract
>>>> classes.
>>>>
>>>> If you're using the GIRepository API, you can use
>>>> `g_object_info_get_abstract()` to know if a type is abstract.
>>>>
>>>> Ciao,
>>>>  Emmanuele.
>>>>
>>>> On 8 November 2017 at 16:40, Sam Jansen <sam.jan...@starleaf.com>
>wrote:
>>>> > Perhaps you can check whether any methods are constructors? This
>is
>>>> > effectively the information I look at when parsing GIR files for
>my TS
>>>> > definitions...
>>>> >
>>>> > http://devdocs.baznga.org/girepository20~2.0_api/girepositor
>>>> y.functioninfoflags#default-is_constructor
>>>> >
>>>> > On 8 November 2017 at 12:37, Andrea Giammarchi <
>>>> andrea.giammar...@gmail.com>
>>>> > wrote:
>>>> >>
>>>> >> the documentation doesn't say if I can instantiate those
>classes, or
>>>> does
>>>> >> it?
>>>> >>
>>>> >> if I could understand via GIRepository.Repository if a class
>could be
>>>> >> extended/instantiated I could improve cgjs-about to show that
>right
>>>> away.
>>>> >>
>>>> >> So far I thought that `objects` where all usable as `new Class`
>but
>>>> that's
>>>> >> not the case at all. Maybe I should check for an
>`is_abstract_object`
>>>> ?
>>>> >>
>>>> >> Not sure there is anything like that though.
>>>> >>
>>>> >> Thanks.
>>>> >>
>>>> >>
>>>> >> On Wed, Nov 8, 2017 at 3:41 AM, <philip.chime...@gmail.com>
>wrote:
>>>> >>>
>>>> >>> This comes a bit too late to help you, sorry, but the C docs
>will
>>>> tell
>>>> >>> you which classes extend a base class, e.g. for GInputStream
>>>> >>> (Gio.InputStream in GJS):
>>>> >>> https://developer.gnome.org/gio/stable/GInputStream.html#GIn
>>>> putStream.object-hierarchy
>>>> >>>
>>>> >>> On Tue, Nov 7, 2017 at 2:36 PM Andrea Giammarchi
>>>> >>> <andrea.giammar...@gmail.com> wrote:
>>>> >>>>
>>>> >>>> so, just FYI ...
>>>> >>>>
>>>> >>>> Buffered, Converter, Data, File, Memory and Unix InputStream
>are
>>>> >>>> available.
>>>> >>>>
>>>> >>>> Buffered, Converter, and Data need a base_stream to work ...
>not a
>>>> >>>> primitive.
>>>> >>>>
>>>> >>>> File and Unix need attributes or fd pointers
>>>> >>>>
>>>> >>>> The Memory seems to be the "base/primitive" I was looking for
>>>> together
>>>> >>>> with its MemoryOutputStream counterpart.
>>>> >>>>
>>>> >>>> Regards
>>>> >>>>
>>>> >>>>
>>>> >>>>
>>>> >>>> On Tue, Nov 7, 2017 at 7:28 PM, Andrea Giammarchi
>>>> >>>> <andrea.giammar...@gmail.com> wrote:
>>>> >>>>>
>>>> >>>>> oh gosh, my own utility ... that is less useful in pretty
>print for
>>>> >>>>> these kind of things .... although the list has many
>non-usable
>>>> streams but
>>>> >>>>> now I want to know which one is usable.
>>>> >>>>>
>>>> >>>>> P.S. for namespaces you don't' need gi prefix ... cgjs-about
>Gio
>>>> would
>>>> >>>>> do the same ;-)
>>>> >>>>>
>>>> >>>>> Thanks again
>>>> >>>>>
>>>> >>>>> On Tue, Nov 7, 2017 at 7:09 PM, Sam Jansen <
>>>> sam.jan...@starleaf.com>
>>>> >>>>> wrote:
>>>> >>>>>>
>>>> >>>>>>
>>>> >>>>>>
>>>> >>>>>> On 7 November 2017 at 21:55, Andrea Giammarchi
>>>> >>>>>> <andrea.giammar...@gmail.com> wrote:
>>>> >>>>>>>
>>>> >>>>>>> this is gold, thank you!!!
>>>> >>>>>>>
>>>> >>>>>>> do you know if MemoryInputStream is the only one usable? is
>>>> there any
>>>> >>>>>>> list of available GJS streams one can use? I think memory
>is
>>>> just fine
>>>> >>>>>>> though, thanks again a lot!
>>>> >>>>>>>
>>>> >>>>>>
>>>> >>>>>> I just took an educated guess: I figured anything useful
>would
>>>> extend
>>>> >>>>>> Gio.InputStream. I then just browsed through the docs,
>looking
>>>> for anything
>>>> >>>>>> with "InputStream" in their name, which isn't so many...
>>>> >>>>>>
>>>> >>>>>> This is a good place to start perhaps:
>>>> >>>>>>
>>>> >>>>>> $ cgjs-about gi.Gio --json | grep InputStream | grep -Ev
>>>> >>>>>> "Class|Private"
>>>> >>>>>>
>>>> >>>>>>
>>>> >>>>>> It would be a neat extension to cgjs-about if one could have
>it
>>>> list
>>>> >>>>>> the classes known to implement an interface or extend from a
>>>> class...
>>>> >>>>>>
>>>> >>>>>>>
>>>> >>>>>>> On Tue, Nov 7, 2017 at 6:46 PM, Sam Jansen <
>>>> sam.jan...@starleaf.com>
>>>> >>>>>>> wrote:
>>>> >>>>>>>>
>>>> >>>>>>>> Hi Andrea,
>>>> >>>>>>>>
>>>> >>>>>>>> I've come up with something that... almost does what
>you're
>>>> looking
>>>> >>>>>>>> at here. Perhaps it's useful as a guide of what one can do
>with
>>>> the Gio
>>>> >>>>>>>> interface.
>>>> >>>>>>>>
>>>> >>>>>>>> I think you may hit some awkward problems with modelling
>>>> Node-style
>>>> >>>>>>>> streams with GLib ones. But perhaps it is possible and
>this
>>>> helps. I don't
>>>> >>>>>>>> really know the Node stream semantics so I have assumed
>various
>>>> things in my
>>>> >>>>>>>> Readable implementation as you'll see... Note that
>>>> MemoryInputStream really
>>>> >>>>>>>> is just a byte stream; so there is no guarantee you'll
>receive
>>>> the exact
>>>> >>>>>>>> block of bytes that was written -- for example, when I run
>this
>>>> I get a
>>>> >>>>>>>> first chunk of "12", followed by "3", "4", etc.
>>>> >>>>>>>>
>>>> >>>>>>>>
>>>> >>>>>>>> let Gio = imports.gi.Gio;
>>>> >>>>>>>> let byteArray = imports.byteArray;
>>>> >>>>>>>> let mainloop = imports.mainloop;
>>>> >>>>>>>>
>>>> >>>>>>>> class Readable {
>>>> >>>>>>>>   constructor() {
>>>> >>>>>>>>     this._mio = Gio.MemoryInputStream.new();
>>>> >>>>>>>>     this._callbacks = {};
>>>> >>>>>>>>     this._startNext();
>>>> >>>>>>>>   }
>>>> >>>>>>>>
>>>> >>>>>>>>   _startNext() {
>>>> >>>>>>>>     // Enqueue an async read; and re-enqueue when it
>finishes,
>>>> so
>>>> >>>>>>>> we're
>>>> >>>>>>>>     // always waiting for data...
>>>> >>>>>>>>     this._mio.read_bytes_async(4096, 1, null, (source,
>res) =>
>>>> {
>>>> >>>>>>>> this._onData(this._mio.read_bytes_finish(res));
>>>> >>>>>>>>         this._startNext();
>>>> >>>>>>>> });
>>>> >>>>>>>>   }
>>>> >>>>>>>>
>>>> >>>>>>>>   _onData(bytes) {
>>>> >>>>>>>>     if (this._callbacks['data']) {
>>>> >>>>>>>>       let ba = byteArray.fromGBytes(bytes);
>>>> >>>>>>>>       this._callbacks['data'](ba);
>>>> >>>>>>>>       this._read();
>>>> >>>>>>>>     }
>>>> >>>>>>>>   }
>>>> >>>>>>>>
>>>> >>>>>>>>   push(bytes) {
>>>> >>>>>>>>     if (bytes == null) {
>>>> >>>>>>>>       mainloop.quit('main');
>>>> >>>>>>>>       return;
>>>> >>>>>>>>     }
>>>> >>>>>>>>     this._mio.add_bytes(bytes);
>>>> >>>>>>>>   }
>>>> >>>>>>>>
>>>> >>>>>>>>   on(name, callback) {
>>>> >>>>>>>>     this._callbacks[name] = callback;
>>>> >>>>>>>>     if (name === 'data') {
>>>> >>>>>>>>       this._read();
>>>> >>>>>>>>     }
>>>> >>>>>>>>   }
>>>> >>>>>>>> }
>>>> >>>>>>>>
>>>> >>>>>>>> class Counter extends Readable {
>>>> >>>>>>>>   constructor(opt) {
>>>> >>>>>>>>     super(opt);
>>>> >>>>>>>>     this._max = 1000;
>>>> >>>>>>>>     this._index = 1;
>>>> >>>>>>>>   }
>>>> >>>>>>>>
>>>> >>>>>>>>   _read() {
>>>> >>>>>>>>     const i = this._index++;
>>>> >>>>>>>>     if (i > this._max)
>>>> >>>>>>>>       this.push(null);
>>>> >>>>>>>>     else {
>>>> >>>>>>>>       const str = '' + i;
>>>> >>>>>>>>       const buf = byteArray.fromString(str); //
>Buffer.from(str,
>>>> >>>>>>>> 'ascii');
>>>> >>>>>>>>       this.push(buf);
>>>> >>>>>>>>     }
>>>> >>>>>>>>   }
>>>> >>>>>>>> }
>>>> >>>>>>>>
>>>> >>>>>>>> (new Counter).on('data', (str) => {
>>>> >>>>>>>>     print("data", str.toString());
>>>> >>>>>>>> });
>>>> >>>>>>>>
>>>> >>>>>>>> mainloop.run('main');
>>>> >>>>>>>>
>>>> >>>>>>>>
>>>> >>>>>>>> On 7 November 2017 at 10:08, Andrea Giammarchi
>>>> >>>>>>>> <andrea.giammar...@gmail.com> wrote:
>>>> >>>>>>>>>
>>>> >>>>>>>>> I am trying to implement a stream module and apparently I
>have
>>>> >>>>>>>>> everything I need but practically I'm unable to use
>streams.
>>>> >>>>>>>>>
>>>> >>>>>>>>> If I instantiate a `new Gio.InputStream` I have the
>following
>>>> >>>>>>>>> error:
>>>> >>>>>>>>> cannot create instance of abstract (non-instantiatable)
>type
>>>> >>>>>>>>> 'GInputStream'
>>>> >>>>>>>>>
>>>> >>>>>>>>> I cannot even extend it ... so I've though "ok, maybe
>it's
>>>> like an
>>>> >>>>>>>>> interface, I implement it and that's it"
>>>> >>>>>>>>>
>>>> >>>>>>>>> But then a JS class wouldn't work as base_stream for a
>>>> >>>>>>>>> Gio.BufferedInputStream, and if I extend the JS class to
>be a
>>>> GObject.Object
>>>> >>>>>>>>> then:
>>>> >>>>>>>>> Gjs-WARNING **: JS ERROR: TypeError: Object is of type
>>>> >>>>>>>>> GObject.Object - cannot convert to GInputStream
>>>> >>>>>>>>>
>>>> >>>>>>>>> where GInputStream is the one I cannot use in the first
>place.
>>>> >>>>>>>>>
>>>> >>>>>>>>> I've reached full circle then so ... I wonder if anyone
>has any
>>>> >>>>>>>>> idea how to use/create/extend streams in GJS (not talking
>>>> about file streams
>>>> >>>>>>>>> but streams in general) or if it's even possible.
>>>> >>>>>>>>>
>>>> >>>>>>>>> In node, as example, I could do this and it will work:
>>>> >>>>>>>>>
>>>> >>>>>>>>> ```js
>>>> >>>>>>>>>
>>>> >>>>>>>>> const { Readable } = require('stream');
>>>> >>>>>>>>>
>>>> >>>>>>>>> class Counter extends Readable {
>>>> >>>>>>>>> constructor(opt) {
>>>> >>>>>>>>> super(opt);
>>>> >>>>>>>>> this._max = 1000;
>>>> >>>>>>>>> this._index = 1;
>>>> >>>>>>>>> }
>>>> >>>>>>>>>
>>>> >>>>>>>>> _read() {
>>>> >>>>>>>>> const i = this._index++;
>>>> >>>>>>>>> if (i > this._max)
>>>> >>>>>>>>> this.push(null);
>>>> >>>>>>>>> else {
>>>> >>>>>>>>> const str = '' + i;
>>>> >>>>>>>>> const buf = Buffer.from(str, 'ascii');
>>>> >>>>>>>>> this.push(buf);
>>>> >>>>>>>>> }
>>>> >>>>>>>>> }
>>>> >>>>>>>>> }
>>>> >>>>>>>>>
>>>> >>>>>>>>> (new Counter).on('data', console.log);
>>>> >>>>>>>>>
>>>> >>>>>>>>> ```
>>>> >>>>>>>>>
>>>> >>>>>>>>> _______________________________________________
>>>> >>>>>>>>> javascript-list mailing list
>>>> >>>>>>>>> javascript-list@gnome.org
>>>> >>>>>>>>> https://mail.gnome.org/mailman/listinfo/javascript-list
>>>> >>>>>>>>>
>>>> >>>>>>>>
>>>> >>>>>>>
>>>> >>>>>>
>>>> >>>>>
>>>> >>>>
>>>> >>>> _______________________________________________
>>>> >>>> javascript-list mailing list
>>>> >>>> javascript-list@gnome.org
>>>> >>>> https://mail.gnome.org/mailman/listinfo/javascript-list
>>>> >>
>>>> >>
>>>> >
>>>> >
>>>> > _______________________________________________
>>>> > javascript-list mailing list
>>>> > javascript-list@gnome.org
>>>> > https://mail.gnome.org/mailman/listinfo/javascript-list
>>>> >
>>>>
>>>>
>>>>
>>>> --
>>>> https://www.bassi.io
>>>> [@] ebassi [@gmail.com]
>>>>
>>>
>>>
>>> _______________________________________________
>>> javascript-list mailing list
>>> javascript-list@gnome.org
>>> https://mail.gnome.org/mailman/listinfo/javascript-list
>>>
>>>
>>
>> _______________________________________________
>> javascript-list mailing list
>> javascript-list@gnome.org
>> https://mail.gnome.org/mailman/listinfo/javascript-list
>>
>>
_______________________________________________
javascript-list mailing list
javascript-list@gnome.org
https://mail.gnome.org/mailman/listinfo/javascript-list

Reply via email to