From b0c2427cdc59be0bb1fa76e928b17d9aa1a0d4eb Mon Sep 17 00:00:00 2001

From: Martin Milata <mmilata@redhat.com>

Date: Wed, 28 Jan 2015 17:31:41 +0100

Subject: [PATCH] python: add Ruby support

Related: #1334604

Signed-off-by: Martin Milata <mmilata@redhat.com>

Conflicts:

	tests/Makefile.am

---

 python/Makefile.am          |   4 +

 python/py_module.c          |  22 +++++

 python/py_report.c          |   9 ++

 python/py_ruby_frame.c      | 227 ++++++++++++++++++++++++++++++++++++++++++++

 python/py_ruby_frame.h      |  69 ++++++++++++++

 python/py_ruby_stacktrace.c | 182 +++++++++++++++++++++++++++++++++++

 python/py_ruby_stacktrace.h |  71 ++++++++++++++

 tests/Makefile.am           |  11 ++-

 tests/python/ruby.py        | 174 +++++++++++++++++++++++++++++++++

 tests/python_bindings.at    |   1 +

 10 files changed, 769 insertions(+), 1 deletion(-)

 create mode 100644 python/py_ruby_frame.c

 create mode 100644 python/py_ruby_frame.h

 create mode 100644 python/py_ruby_stacktrace.c

 create mode 100644 python/py_ruby_stacktrace.h

 create mode 100755 tests/python/ruby.py

diff --git a/python/Makefile.am b/python/Makefile.am

index 83273a2..9380c12 100644

--- a/python/Makefile.am

+++ b/python/Makefile.am

@@ -44,6 +44,10 @@ _satyr_la_SOURCES = \

     py_java_thread.c \

     py_java_stacktrace.h \

     py_java_stacktrace.c \

+    py_ruby_frame.h \

+    py_ruby_frame.c \

+    py_ruby_stacktrace.h \

+    py_ruby_stacktrace.c \

     py_rpm_package.h \

     py_rpm_package.c \

     py_metrics.h \

diff --git a/python/py_module.c b/python/py_module.c

index 83697ef..144465b 100644

--- a/python/py_module.c

+++ b/python/py_module.c

@@ -17,6 +17,8 @@

 #include "py_core_frame.h"

 #include "py_core_thread.h"

 #include "py_core_stacktrace.h"

+#include "py_ruby_frame.h"

+#include "py_ruby_stacktrace.h"

 #include "py_rpm_package.h"

 #include "py_metrics.h"

 #include "py_operating_system.h"

@@ -187,6 +189,18 @@ init_satyr()

         return;

     }

+    if (PyType_Ready(&sr_py_ruby_frame_type) < 0)

+    {

+        puts("PyType_Ready(&sr_py_ruby_frame_type) < 0");

+        return;

+    }

+

+    if (PyType_Ready(&sr_py_ruby_stacktrace_type) < 0)

+    {

+        puts("PyType_Ready(&sr_py_ruby_stacktrace_type) < 0");

+        return;

+    }

+

     if (PyType_Ready(&sr_py_operating_system_type) < 0)

     {

         puts("PyType_Ready(&sr_py_operating_system_type) < 0");

@@ -301,6 +315,14 @@ init_satyr()

     PyModule_AddObject(module, "JavaStacktrace",

                        (PyObject *)&sr_py_java_stacktrace_type);

+    Py_INCREF(&sr_py_ruby_frame_type);

+    PyModule_AddObject(module, "RubyFrame",

+                       (PyObject *)&sr_py_ruby_frame_type);

+

+    Py_INCREF(&sr_py_ruby_stacktrace_type);

+    PyModule_AddObject(module, "RubyStacktrace",

+                       (PyObject *)&sr_py_ruby_stacktrace_type);

+

     Py_INCREF(&sr_py_core_frame_type);

     PyModule_AddObject(module, "CoreFrame",

                        (PyObject *)&sr_py_core_frame_type);

diff --git a/python/py_report.c b/python/py_report.c

index 8aa35dd..74cd9dd 100644

--- a/python/py_report.c

+++ b/python/py_report.c

@@ -28,6 +28,7 @@

 #include "py_python_stacktrace.h"

 #include "py_koops_stacktrace.h"

 #include "py_java_stacktrace.h"

+#include "py_ruby_stacktrace.h"

 #include "report.h"

 #include "operating_system.h"

@@ -284,6 +285,10 @@ report_prepare_subobjects(struct sr_py_report *report)

             if (stacktrace_prepare(report, &sr_py_koops_stacktrace_type, false) < 0)

                 return -1;

             break;

+        case SR_REPORT_RUBY:

+            if (stacktrace_prepare(report, &sr_py_ruby_stacktrace_type, false) < 0)

+                return -1;

+            break;

         default:

             report->report->stacktrace = NULL;

             break;

@@ -347,6 +352,10 @@ report_to_python_obj(struct sr_report *report)

             ro->stacktrace = koops_stacktrace_to_python_obj(

                     (struct sr_koops_stacktrace *)report->stacktrace);

             break;

+        case SR_REPORT_RUBY:

+            ro->stacktrace = ruby_stacktrace_to_python_obj(

+                    (struct sr_ruby_stacktrace *)report->stacktrace);

+            break;

         default:

             Py_INCREF(Py_None);

             ro->stacktrace = Py_None;

diff --git a/python/py_ruby_frame.c b/python/py_ruby_frame.c

new file mode 100644

index 0000000..9ed45ad

--- /dev/null

+++ b/python/py_ruby_frame.c

@@ -0,0 +1,227 @@

+/*

+    py_ruby_frame.c

+

+    Copyright (C) 2015  Red Hat, Inc.

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#include "py_common.h"

+#include "py_base_frame.h"

+#include "py_ruby_frame.h"

+#include "location.h"

+#include "strbuf.h"

+#include "utils.h"

+#include "ruby/frame.h"

+

+#define frame_doc "satyr.RubyFrame - class representing a ruby frame\n\n" \

+                  "Usage:\n\n" \

+                  "satyr.RubyFrame() - creates an empty frame\n\n" \

+                  "satyr.RubyFrame(str) - parses str and fills the frame object"

+

+#define f_dup_doc "Usage: frame.dup()\n\n" \

+                  "Returns: satyr.RubyFrame - a new clone of frame\n\n" \

+                  "Clones the frame object. All new structures are independent " \

+                  "of the original object."

+

+

+static PyMethodDef

+frame_methods[] =

+{

+    /* methods */

+    { "dup", sr_py_ruby_frame_dup, METH_NOARGS,  f_dup_doc },

+    { NULL },

+};

+

+/* See python/py_common.h and python/py_gdb_frame.c for generic getters/setters documentation. */

+#define GSOFF_PY_STRUCT sr_py_ruby_frame

+#define GSOFF_PY_MEMBER frame

+#define GSOFF_C_STRUCT sr_ruby_frame

+GSOFF_START

+GSOFF_MEMBER(file_name),

+GSOFF_MEMBER(file_line),

+GSOFF_MEMBER(special_function),

+GSOFF_MEMBER(function_name),

+GSOFF_MEMBER(block_level),

+GSOFF_MEMBER(rescue_level)

+GSOFF_END

+

+static PyGetSetDef

+frame_getset[] =

+{

+    SR_ATTRIBUTE_STRING(file_name,        "Source file name (string)"                              ),

+    SR_ATTRIBUTE_UINT32(file_line,        "Source line number (positive integer)"                  ),

+    SR_ATTRIBUTE_BOOL  (special_function, "True if the frame doesn't belong to an actual function" ),

+    SR_ATTRIBUTE_STRING(function_name,    "Function name (string)"                                 ),

+    SR_ATTRIBUTE_UINT32(block_level,      "Block nesting level (integer)"                          ),

+    SR_ATTRIBUTE_UINT32(rescue_level,     "Rescue block nesting level (integer)"                   ),

+    { NULL },

+};

+

+PyTypeObject

+sr_py_ruby_frame_type =

+{

+    PyObject_HEAD_INIT(NULL)

+    0,

+    "satyr.RubyFrame",          /* tp_name */

+    sizeof(struct sr_py_ruby_frame), /* tp_basicsize */

+    0,                          /* tp_itemsize */

+    sr_py_ruby_frame_free,      /* tp_dealloc */

+    NULL,                       /* tp_print */

+    NULL,                       /* tp_getattr */

+    NULL,                       /* tp_setattr */

+    NULL,                       /* tp_compare */

+    NULL,                       /* tp_repr */

+    NULL,                       /* tp_as_number */

+    NULL,                       /* tp_as_sequence */

+    NULL,                       /* tp_as_mapping */

+    NULL,                       /* tp_hash */

+    NULL,                       /* tp_call */

+    sr_py_ruby_frame_str,       /* tp_str */

+    NULL,                       /* tp_getattro */

+    NULL,                       /* tp_setattro */

+    NULL,                       /* tp_as_buffer */

+    Py_TPFLAGS_DEFAULT,         /* tp_flags */

+    frame_doc,                  /* tp_doc */

+    NULL,                       /* tp_traverse */

+    NULL,                       /* tp_clear */

+    NULL,                       /* tp_richcompare */

+    0,                          /* tp_weaklistoffset */

+    NULL,                       /* tp_iter */

+    NULL,                       /* tp_iternext */

+    frame_methods,              /* tp_methods */

+    NULL,                       /* tp_members */

+    frame_getset,               /* tp_getset */

+    &sr_py_base_frame_type,     /* tp_base */

+    NULL,                       /* tp_dict */

+    NULL,                       /* tp_descr_get */

+    NULL,                       /* tp_descr_set */

+    0,                          /* tp_dictoffset */

+    NULL,                       /* tp_init */

+    NULL,                       /* tp_alloc */

+    sr_py_ruby_frame_new,       /* tp_new */

+    NULL,                       /* tp_free */

+    NULL,                       /* tp_is_gc */

+    NULL,                       /* tp_bases */

+    NULL,                       /* tp_mro */

+    NULL,                       /* tp_cache */

+    NULL,                       /* tp_subclasses */

+    NULL,                       /* tp_weaklist */

+};

+

+/* constructor */

+PyObject *

+sr_py_ruby_frame_new(PyTypeObject *object, PyObject *args, PyObject *kwds)

+{

+    struct sr_py_ruby_frame *fo = (struct sr_py_ruby_frame*)

+        PyObject_New(struct sr_py_ruby_frame, &sr_py_ruby_frame_type);

+

+    if (!fo)

+        return PyErr_NoMemory();

+

+    const char *str = NULL;

+    if (!PyArg_ParseTuple(args, "|s", &str))

+        return NULL;

+

+    if (str)

+    {

+        struct sr_location location;

+        sr_location_init(&location);

+        fo->frame = sr_ruby_frame_parse(&str, &location);

+

+        if (!fo->frame)

+        {

+            PyErr_SetString(PyExc_ValueError, location.message);

+            return NULL;

+        }

+    }

+    else

+        fo->frame = sr_ruby_frame_new();

+

+    return (PyObject*)fo;

+}

+

+/* destructor */

+void

+sr_py_ruby_frame_free(PyObject *object)

+{

+    struct sr_py_ruby_frame *this = (struct sr_py_ruby_frame*)object;

+    sr_ruby_frame_free(this->frame);

+    PyObject_Del(object);

+}

+

+/* str */

+PyObject *

+sr_py_ruby_frame_str(PyObject *self)

+{

+    struct sr_py_ruby_frame *this = (struct sr_py_ruby_frame*)self;

+    struct sr_strbuf *buf = sr_strbuf_new();

+

+

+    if (this->frame->file_name)

+    {

+        sr_strbuf_append_str(buf, this->frame->file_name);

+    }

+

+    if (this->frame->file_line)

+    {

+        sr_strbuf_append_strf(buf, ":%d", this->frame->file_line);

+    }

+

+    if (this->frame->function_name)

+    {

+        sr_strbuf_append_str(buf, ":in `");

+

+        int i;

+        for (i = 0; i < this->frame->rescue_level; i++)

+        {

+            sr_strbuf_append_str(buf, "rescue in ");

+        }

+

+        if (this->frame->block_level == 1)

+        {

+            sr_strbuf_append_str(buf, "block in ");

+        }

+        else if (this->frame->block_level > 1)

+        {

+            sr_strbuf_append_strf(buf, "block (%d levels) in ", this->frame->block_level);

+        }

+

+        sr_strbuf_append_strf(buf, "%s%s%s'",

+                              (this->frame->special_function ? "<" : ""),

+                              this->frame->function_name,

+                              (this->frame->special_function ? ">" : ""));

+    }

+

+    char *str = sr_strbuf_free_nobuf(buf);

+    PyObject *result = Py_BuildValue("s", str);

+    free(str);

+    return result;

+}

+

+/* methods */

+PyObject *

+sr_py_ruby_frame_dup(PyObject *self, PyObject *args)

+{

+    struct sr_py_ruby_frame *this = (struct sr_py_ruby_frame*)self;

+    struct sr_py_ruby_frame *fo = (struct sr_py_ruby_frame*)

+        PyObject_New(struct sr_py_ruby_frame, &sr_py_ruby_frame_type);

+

+    if (!fo)

+        return PyErr_NoMemory();

+

+    fo->frame = sr_ruby_frame_dup(this->frame, false);

+

+    return (PyObject*)fo;

+}

diff --git a/python/py_ruby_frame.h b/python/py_ruby_frame.h

new file mode 100644

index 0000000..7f460ff

--- /dev/null

+++ b/python/py_ruby_frame.h

@@ -0,0 +1,69 @@

+/*

+    py_ruby_frame.h

+

+    Copyright (C) 2015  Red Hat, Inc.

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#ifndef SATYR_PY_RUBY_FRAME_H

+#define SATYR_PY_RUBY_FRAME_H

+

+/**

+ * @file

+ * @brief Python bindings for RUBY frame.

+ */

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#include <Python.h>

+#include <structmember.h>

+

+PyTypeObject sr_py_ruby_frame_type;

+

+/* The beginning of this structure has to have the same layout as

+ * sr_py_base_frame.

+ */

+struct sr_py_ruby_frame

+{

+    PyObject_HEAD

+    struct sr_ruby_frame *frame;

+};

+

+/**

+ * Constructor.

+ */

+PyObject *sr_py_ruby_frame_new(PyTypeObject *object,

+                               PyObject *args, PyObject *kwds);

+

+/**

+ * Destructor.

+ */

+void sr_py_ruby_frame_free(PyObject *object);

+

+/**

+ * str

+ */

+PyObject *sr_py_ruby_frame_str(PyObject *self);

+

+/* methods */

+PyObject *sr_py_ruby_frame_dup(PyObject *self, PyObject *args);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/python/py_ruby_stacktrace.c b/python/py_ruby_stacktrace.c

new file mode 100644

index 0000000..97fbb44

--- /dev/null

+++ b/python/py_ruby_stacktrace.c

@@ -0,0 +1,182 @@

+#include "py_common.h"

+#include "py_ruby_frame.h"

+#include "py_ruby_stacktrace.h"

+#include "py_base_stacktrace.h"

+#include "utils.h"

+#include "strbuf.h"

+#include "ruby/frame.h"

+#include "ruby/stacktrace.h"

+#include "location.h"

+#include "stacktrace.h"

+

+#define stacktrace_doc "satyr.RubyStacktrace - class representing a ruby stacktrace\n\n" \

+                       "Usage:\n\n" \

+                       "satyr.RubyStacktrace() - creates an empty ruby stacktrace\n\n" \

+                       "satyr.RubyStacktrace(str) - parses str and fills the ruby stacktrace object"

+

+#define f_dup_doc "Usage: stacktrace.dup()\n\n" \

+                  "Returns: satyr.RubyStacktrace - a new clone of ruby stacktrace\n\n" \

+                  "Clones the RubyStacktrace object. All new structures are independent " \

+                  "of the original object."

+

+

+static PyMethodDef

+ruby_stacktrace_methods[] =

+{

+    /* methods */

+    { "dup", sr_py_ruby_stacktrace_dup, METH_NOARGS, f_dup_doc },

+    { NULL },

+};

+

+/* See python/py_common.h and python/py_gdb_frame.c for generic getters/setters documentation. */

+#define GSOFF_PY_STRUCT sr_py_ruby_stacktrace

+#define GSOFF_PY_MEMBER stacktrace

+#define GSOFF_C_STRUCT sr_ruby_stacktrace

+GSOFF_START

+GSOFF_MEMBER(exception_name)

+GSOFF_END

+

+static PyGetSetDef

+ruby_stacktrace_getset[] =

+{

+    SR_ATTRIBUTE_STRING(exception_name, "Exception type (string)"              ),

+    { NULL },

+};

+

+PyTypeObject sr_py_ruby_stacktrace_type = {

+    PyObject_HEAD_INIT(NULL)

+    0,

+    "satyr.RubyStacktrace",         /* tp_name */

+    sizeof(struct sr_py_ruby_stacktrace), /* tp_basicsize */

+    0,                              /* tp_itemsize */

+    sr_py_ruby_stacktrace_free,     /* tp_dealloc */

+    NULL,                           /* tp_print */

+    NULL,                           /* tp_getattr */

+    NULL,                           /* tp_setattr */

+    NULL,                           /* tp_compare */

+    NULL,                           /* tp_repr */

+    NULL,                           /* tp_as_number */

+    NULL,                           /* tp_as_sequence */

+    NULL,                           /* tp_as_mapping */

+    NULL,                           /* tp_hash */

+    NULL,                           /* tp_call */

+    sr_py_ruby_stacktrace_str,      /* tp_str */

+    NULL,                           /* tp_getattro */

+    NULL,                           /* tp_setattro */

+    NULL,                           /* tp_as_buffer */

+    Py_TPFLAGS_DEFAULT,             /* tp_flags */

+    stacktrace_doc,                 /* tp_doc */

+    NULL,                           /* tp_traverse */

+    NULL,                           /* tp_clear */

+    NULL,                           /* tp_richcompare */

+    0,                              /* tp_weaklistoffset */

+    NULL,                           /* tp_iter */

+    NULL,                           /* tp_iternext */

+    ruby_stacktrace_methods,        /* tp_methods */

+    NULL,                           /* tp_members */

+    ruby_stacktrace_getset,         /* tp_getset */

+    &sr_py_single_stacktrace_type,  /* tp_base */

+    NULL,                           /* tp_dict */

+    NULL,                           /* tp_descr_get */

+    NULL,                           /* tp_descr_set */

+    0,                              /* tp_dictoffset */

+    NULL,                           /* tp_init */

+    NULL,                           /* tp_alloc */

+    sr_py_ruby_stacktrace_new,      /* tp_new */

+    NULL,                           /* tp_free */

+    NULL,                           /* tp_is_gc */

+    NULL,                           /* tp_bases */

+    NULL,                           /* tp_mro */

+    NULL,                           /* tp_cache */

+    NULL,                           /* tp_subclasses */

+    NULL,                           /* tp_weaklist */

+};

+

+PyObject *

+ruby_stacktrace_to_python_obj(struct sr_ruby_stacktrace *stacktrace)

+{

+    struct sr_py_ruby_stacktrace *bo = PyObject_New(struct sr_py_ruby_stacktrace,

+                                                    &sr_py_ruby_stacktrace_type);

+    if (!bo)

+        return PyErr_NoMemory();

+

+    bo->frame_type = &sr_py_ruby_frame_type;

+

+    bo->stacktrace = stacktrace;

+    bo->frames = frames_to_python_list((struct sr_thread *)bo->stacktrace,

+                                       bo->frame_type);

+    if (!bo->frames)

+        return NULL;

+

+    return (PyObject *)bo;

+}

+

+/* constructor */

+PyObject *

+sr_py_ruby_stacktrace_new(PyTypeObject *object,

+                            PyObject *args,

+                            PyObject *kwds)

+{

+    const char *str = NULL;

+    if (!PyArg_ParseTuple(args, "|s", &str))

+        return NULL;

+

+    struct sr_ruby_stacktrace *stacktrace;

+

+    if (str)

+    {

+        struct sr_location location;

+        sr_location_init(&location);

+        stacktrace = sr_ruby_stacktrace_parse(&str, &location);

+        if (!stacktrace)

+        {

+            PyErr_SetString(PyExc_ValueError, location.message);

+            return NULL;

+        }

+    }

+    else

+        stacktrace = sr_ruby_stacktrace_new();

+

+    return ruby_stacktrace_to_python_obj(stacktrace);

+}

+

+/* destructor */

+void

+sr_py_ruby_stacktrace_free(PyObject *object)

+{

+    struct sr_py_ruby_stacktrace *this = (struct sr_py_ruby_stacktrace*)object;

+    /* the list will decref all of its elements */

+    Py_DECREF(this->frames);

+    this->stacktrace->frames = NULL;

+    sr_ruby_stacktrace_free(this->stacktrace);

+    PyObject_Del(object);

+}

+

+/* str */

+PyObject *

+sr_py_ruby_stacktrace_str(PyObject *self)

+{

+    struct sr_py_ruby_stacktrace *this = (struct sr_py_ruby_stacktrace *)self;

+    struct sr_strbuf *buf = sr_strbuf_new();

+    sr_strbuf_append_strf(buf, "Ruby stacktrace with %zd frames",

+                         (ssize_t)(PyList_Size(this->frames)));

+    char *str = sr_strbuf_free_nobuf(buf);

+    PyObject *result = Py_BuildValue("s", str);

+    free(str);

+    return result;

+}

+

+/* methods */

+PyObject *

+sr_py_ruby_stacktrace_dup(PyObject *self, PyObject *args)

+{

+    struct sr_py_ruby_stacktrace *this = (struct sr_py_ruby_stacktrace*)self;

+    if (frames_prepare_linked_list((struct sr_py_base_thread *)this) < 0)

+        return NULL;

+

+    struct sr_ruby_stacktrace *stacktrace = sr_ruby_stacktrace_dup(this->stacktrace);

+    if (!stacktrace)

+        return NULL;

+

+    return ruby_stacktrace_to_python_obj(stacktrace);

+}

diff --git a/python/py_ruby_stacktrace.h b/python/py_ruby_stacktrace.h

new file mode 100644

index 0000000..f4eebce

--- /dev/null

+++ b/python/py_ruby_stacktrace.h

@@ -0,0 +1,71 @@

+/*

+    py_ruby_stacktrace.h

+

+    Copyright (C) 2015  Red Hat, Inc.

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#ifndef SATYR_PY_RUBY_STACKTRACE_H

+#define SATYR_PY_RUBY_STACKTRACE_H

+

+/**

+ * @file

+ * @brief Python bindings for Ruby stack trace.

+ */

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#include <Python.h>

+#include <structmember.h>

+

+PyTypeObject sr_py_ruby_stacktrace_type;

+

+/* The beginning of this structure has to have the same layout as

+ * sr_py_base_thread.

+ */

+struct sr_py_ruby_stacktrace

+{

+    PyObject_HEAD

+    struct sr_ruby_stacktrace *stacktrace;

+    PyObject *frames;

+    PyTypeObject *frame_type;

+};

+

+/* helpers */

+PyObject *ruby_stacktrace_to_python_obj(struct sr_ruby_stacktrace *stacktrace);

+

+/* constructor */

+PyObject *sr_py_ruby_stacktrace_new(PyTypeObject *object,

+                                    PyObject *args,

+                                    PyObject *kwds);

+

+/* destructor */

+void sr_py_ruby_stacktrace_free(PyObject *object);

+

+/* str */

+PyObject *sr_py_ruby_stacktrace_str(PyObject *self);

+

+/* methods */

+PyObject *sr_py_ruby_stacktrace_dup(PyObject *self, PyObject *args);

+PyObject *sr_py_ruby_stacktrace_normalize(PyObject *self, PyObject *args);

+

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/tests/Makefile.am b/tests/Makefile.am

index 0eb33a5..b261880 100644

--- a/tests/Makefile.am

+++ b/tests/Makefile.am

@@ -4,7 +4,16 @@ EXTRA_DIST = gdb_stacktraces \

              json_files \

              kerneloopses \

              programs \

-             python \

+             python/core.py \

+             python/gdb.py \

+             python/java.py \

+             python/koops.py \

+             python/metrics.py \

+             python/misc.py \

+             python/python.py \

+             python/report.py \

+             python/ruby.py \

+             python/test_helpers.py \

              python_stacktraces