[PATCH v3 0/7] ruby: object cleanups

[Felipe Contreras <felipe.contreras@gmail.com>]

This is basically the same as v2, except I updated the commit messages as David Bremner suggested,
and I added a minor comment.

Felipe Contreras (7):
  ruby: simplify data get helper
  ruby: fetch class name in case of error
  ruby: add unlikely hint
  ruby: create Data_Wrap_Notmuch_Object helper
  ruby: move towards more modern RTypedData
  ruby: add all data types
  ruby: new notmuch_rb_object_destroy() helper

 bindings/ruby/database.c  | 22 ++++++---------
 bindings/ruby/defs.h      | 59 +++++++++++++++++++++++++++++----------
 bindings/ruby/directory.c | 11 ++------
 bindings/ruby/filenames.c |  7 +----
 bindings/ruby/init.c      | 21 ++++++++++++++
 bindings/ruby/message.c   | 13 +++------
 bindings/ruby/messages.c  | 11 ++------
 bindings/ruby/query.c     | 11 ++------
 bindings/ruby/tags.c      |  7 +----
 bindings/ruby/thread.c    | 13 +++------
 bindings/ruby/threads.c   |  9 ++----
 11 files changed, 96 insertions(+), 88 deletions(-)

Range-diff against v2:
 1:  9c15fc44 <  -:  -------- ruby: add missing Data_Get_Notmuch helpers
 2:  c9d840d3 <  -:  -------- ruby: improve all Data_Get_Notmuch_* helpers
 3:  299b2be1 <  -:  -------- ruby: improve general data get helper
 4:  19fa26de !  1:  a1dc3960 ruby: simplify data get helper
    @@ Metadata
      ## Commit message ##
         ruby: simplify data get helper
     
    -    The type is not actually needed.
    +    Data_Get_Struct is nothing but a macro that calls
    +    rb_data_object_get with a cast (unnecessary in C).
    +
    +            #define Data_Get_Struct(obj, type, sval) \
    +                ((sval) = RBIMPL_CAST((type*)rb_data_object_get(obj)))
    +
    +    We can use rb_data_object_get directly, and this way we don't need to
    +    pass the type, which is unnecessary information.
     
         Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>
     
 5:  1872c4b5 =  2:  2f88cf0a ruby: fetch class name in case of error
 6:  b46bcac8 =  3:  6671b155 ruby: add unlikely hint
 7:  1bfa0334 =  4:  87222fd0 ruby: create Data_Wrap_Notmuch_Object helper
 8:  a9b7ac45 !  5:  1a3866c1 ruby: move towards more modern RTypedData
    @@ Metadata
      ## Commit message ##
         ruby: move towards more modern RTypedData
     
    +    Virtually the whole ruby core moved from RData to RTypeData, let's do so
    +    ourselves too.
    +
    +    Basically the information typically passed through Data_Wrap_Struct is
    +    now stored in a struct rb_data_type_t (mark and free functions). This
    +    has the advantage that more information can be easily added, like the
    +    name of the type, a custom data ponter, and more.
    +
    +    Data_Wrap_Struct is replaced with TypedData_Wrap_Struct, and the
    +    information is stored in a struct rb_data_type_t, rather than passed
    +    as arguments.
    +
    +    Check_Type is replaced with Check_TypedStruct, which is a wrapper for
    +    rb_check_typeddata (with casts).
    +
    +            #define Check_TypedStruct(v, t)      \
    +                rb_check_typeddata(RBIMPL_CAST((VALUE)(v)), (t))
    +
    +    We can use rb_check_typeddata directly, just like we use rb_data_object_get
    +    directly.
    +
         Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>
     
      ## bindings/ruby/database.c ##
 9:  e2116d5d =  6:  b3366e12 ruby: add all data types
10:  f6660e5b !  7:  05795b05 ruby: new notmuch_rb_object_destroy() helper
    @@ Metadata
      ## Commit message ##
         ruby: new notmuch_rb_object_destroy() helper
     
    +    The struct used to store the types (rb_data_type_t) contains a "data"
    +    field where we can store whatever we want. I use that field to store a
    +    pointer to the corresponding destroy function. For example
    +    notmuch_rb_database_type contains a pointer to notmuch_database_destroy.
    +
    +    I cast that pointer as a notmuch_status_t (func*)(void *) and call
    +    that function passing the internal object (e.g. notmuch_database_t).
    +
         Using the rb_data_type_t data we can call the correct notmuch destroy
         function.
     
    +    Therefore this:
    +
    +      ret = ((notmuch_status_t (*)(void *)) type->data) (nm_object);
    +
    +    Is effectively the same as this:
    +
    +      ret = notmuch_database_destroy (database);
    +
    +    The advantage of doing it this way is that much less code is necesary
    +    since each rb_data_type_t has the corresponding destroy function stored
    +    in it.
    +
         Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>
     
      ## bindings/ruby/database.c ##
    @@ bindings/ruby/defs.h: extern const rb_data_type_t notmuch_rb_tags_type;
     +
     +    Data_Get_Notmuch_Object (rb_object, type, nm_object);
     +
    ++    /* Call the corresponding notmuch_*_destroy function */
     +    ret = ((notmuch_status_t (*)(void *)) type->data) (nm_object);
     +    DATA_PTR (rb_object) = NULL;
     +
-- 
2.31.1