ntcharts 0.1.0-arm-linux-musl

data/ext/ntcharts/extension.h

@@ -0,0 +1,92 @@
+#ifndef NTCHARTS_EXTENSION_H
+#define NTCHARTS_EXTENSION_H
+
+#include <ruby.h>
+#include "libntcharts.h"
+
+extern VALUE mNtcharts;
+extern VALUE cSparkline;
+extern VALUE cBarchart;
+extern VALUE cLinechart;
+extern VALUE cWavelinechart;
+extern VALUE cStreamlinechart;
+extern VALUE cTimeserieslinechart;
+extern VALUE cStyle;
+
+extern const rb_data_type_t sparkline_type;
+extern const rb_data_type_t barchart_type;
+extern const rb_data_type_t linechart_type;
+extern const rb_data_type_t wavelinechart_type;
+extern const rb_data_type_t streamlinechart_type;
+extern const rb_data_type_t timeserieslinechart_type;
+extern const rb_data_type_t style_type;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_sparkline_t;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_barchart_t;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_linechart_t;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_wavelinechart_t;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_streamlinechart_t;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_timeserieslinechart_t;
+
+typedef struct {
+  unsigned long long handle;
+} ntcharts_style_t;
+
+#define GET_SPARKLINE(self, sparkline) \
+  ntcharts_sparkline_t *sparkline; \
+  TypedData_Get_Struct(self, ntcharts_sparkline_t, &sparkline_type, sparkline)
+
+#define GET_BARCHART(self, barchart) \
+  ntcharts_barchart_t *barchart; \
+  TypedData_Get_Struct(self, ntcharts_barchart_t, &barchart_type, barchart)
+
+#define GET_LINECHART(self, linechart) \
+  ntcharts_linechart_t *linechart; \
+  TypedData_Get_Struct(self, ntcharts_linechart_t, &linechart_type, linechart)
+
+#define GET_WAVELINECHART(self, wavelinechart) \
+  ntcharts_wavelinechart_t *wavelinechart; \
+  TypedData_Get_Struct(self, ntcharts_wavelinechart_t, &wavelinechart_type, wavelinechart)
+
+#define GET_STREAMLINECHART(self, streamlinechart) \
+  ntcharts_streamlinechart_t *streamlinechart; \
+  TypedData_Get_Struct(self, ntcharts_streamlinechart_t, &streamlinechart_type, streamlinechart)
+
+#define GET_TIMESERIESLINECHART(self, timeserieslinechart) \
+  ntcharts_timeserieslinechart_t *timeserieslinechart; \
+  TypedData_Get_Struct(self, ntcharts_timeserieslinechart_t, &timeserieslinechart_type, timeserieslinechart)
+
+#define GET_STYLE(self, style) \
+  ntcharts_style_t *style; \
+  TypedData_Get_Struct(self, ntcharts_style_t, &style_type, style)
+
+VALUE sparkline_wrap(VALUE klass, unsigned long long handle);
+VALUE barchart_wrap(VALUE klass, unsigned long long handle);
+VALUE style_wrap(VALUE klass, unsigned long long handle);
+
+void Init_ntcharts_sparkline(void);
+void Init_ntcharts_barchart(void);
+void Init_ntcharts_linechart(void);
+void Init_ntcharts_wavelinechart(void);
+void Init_ntcharts_streamlinechart(void);
+void Init_ntcharts_timeserieslinechart(void);
+void Init_ntcharts_style(void);
+
+#endif

data/ext/ntcharts/linechart.c

@@ -0,0 +1,341 @@
+#include "extension.h"
+
+static void linechart_free(void *pointer) {
+  ntcharts_linechart_t *linechart = (ntcharts_linechart_t *)pointer;
+  if (linechart->handle != 0) {
+    ntcharts_linechart_free(linechart->handle);
+  }
+  xfree(linechart);
+}
+
+static size_t linechart_memsize(const void *pointer) {
+  return sizeof(ntcharts_linechart_t);
+}
+
+const rb_data_type_t linechart_type = {
+  .wrap_struct_name = "Ntcharts::Linechart",
+  .function = {
+    .dmark = NULL,
+    .dfree = linechart_free,
+    .dsize = linechart_memsize,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE linechart_alloc(VALUE klass) {
+  ntcharts_linechart_t *linechart = ALLOC(ntcharts_linechart_t);
+  linechart->handle = 0;
+  return TypedData_Wrap_Struct(klass, &linechart_type, linechart);
+}
+
+VALUE linechart_wrap(VALUE klass, unsigned long long handle) {
+  ntcharts_linechart_t *linechart = ALLOC(ntcharts_linechart_t);
+  linechart->handle = handle;
+  return TypedData_Wrap_Struct(klass, &linechart_type, linechart);
+}
+
+static VALUE linechart_initialize(int argc, VALUE *argv, VALUE self) {
+  GET_LINECHART(self, linechart);
+
+  if (argc == 2) {
+    // Auto-range mode: width, height only
+    linechart->handle = ntcharts_linechart_new_with_auto_range(NUM2INT(argv[0]), NUM2INT(argv[1]));
+  } else if (argc == 6) {
+    // Full mode: width, height, min_x, max_x, min_y, max_y
+    linechart->handle = ntcharts_linechart_new(
+      NUM2INT(argv[0]), NUM2INT(argv[1]),
+      NUM2DBL(argv[2]), NUM2DBL(argv[3]),
+      NUM2DBL(argv[4]), NUM2DBL(argv[5])
+    );
+  } else {
+    rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 2 or 6)", argc);
+  }
+
+  return self;
+}
+
+static VALUE linechart_width(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return INT2NUM(ntcharts_linechart_width(linechart->handle));
+}
+
+static VALUE linechart_height(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return INT2NUM(ntcharts_linechart_height(linechart->handle));
+}
+
+static VALUE linechart_graph_width(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return INT2NUM(ntcharts_linechart_graph_width(linechart->handle));
+}
+
+static VALUE linechart_graph_height(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return INT2NUM(ntcharts_linechart_graph_height(linechart->handle));
+}
+
+static VALUE linechart_min_x(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_min_x(linechart->handle));
+}
+
+static VALUE linechart_max_x(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_max_x(linechart->handle));
+}
+
+static VALUE linechart_min_y(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_min_y(linechart->handle));
+}
+
+static VALUE linechart_max_y(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_max_y(linechart->handle));
+}
+
+static VALUE linechart_view_min_x(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_view_min_x(linechart->handle));
+}
+
+static VALUE linechart_view_max_x(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_view_max_x(linechart->handle));
+}
+
+static VALUE linechart_view_min_y(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_view_min_y(linechart->handle));
+}
+
+static VALUE linechart_view_max_y(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return DBL2NUM(ntcharts_linechart_view_max_y(linechart->handle));
+}
+
+static VALUE linechart_x_step(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return INT2NUM(ntcharts_linechart_x_step(linechart->handle));
+}
+
+static VALUE linechart_y_step(VALUE self) {
+  GET_LINECHART(self, linechart);
+  return INT2NUM(ntcharts_linechart_y_step(linechart->handle));
+}
+
+static VALUE linechart_set_x_step(VALUE self, VALUE step) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_set_x_step(linechart->handle, NUM2INT(step));
+  return self;
+}
+
+static VALUE linechart_set_y_step(VALUE self, VALUE step) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_set_y_step(linechart->handle, NUM2INT(step));
+  return self;
+}
+
+static VALUE linechart_set_x_range(VALUE self, VALUE min_val, VALUE max_val) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_set_x_range(linechart->handle, NUM2DBL(min_val), NUM2DBL(max_val));
+  return self;
+}
+
+static VALUE linechart_set_y_range(VALUE self, VALUE min_val, VALUE max_val) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_set_y_range(linechart->handle, NUM2DBL(min_val), NUM2DBL(max_val));
+  return self;
+}
+
+static VALUE linechart_set_view_x_range(VALUE self, VALUE min_val, VALUE max_val) {
+  GET_LINECHART(self, linechart);
+  int result = ntcharts_linechart_set_view_x_range(linechart->handle, NUM2DBL(min_val), NUM2DBL(max_val));
+  return result ? Qtrue : Qfalse;
+}
+
+static VALUE linechart_set_view_y_range(VALUE self, VALUE min_val, VALUE max_val) {
+  GET_LINECHART(self, linechart);
+  int result = ntcharts_linechart_set_view_y_range(linechart->handle, NUM2DBL(min_val), NUM2DBL(max_val));
+  return result ? Qtrue : Qfalse;
+}
+
+static VALUE linechart_set_auto_x_range(VALUE self, VALUE auto_min, VALUE auto_max) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_set_auto_x_range(linechart->handle, RTEST(auto_min) ? 1 : 0, RTEST(auto_max) ? 1 : 0);
+  return self;
+}
+
+static VALUE linechart_set_auto_y_range(VALUE self, VALUE auto_min, VALUE auto_max) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_set_auto_y_range(linechart->handle, RTEST(auto_min) ? 1 : 0, RTEST(auto_max) ? 1 : 0);
+  return self;
+}
+
+static VALUE linechart_resize(VALUE self, VALUE width, VALUE height) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_resize(linechart->handle, NUM2INT(width), NUM2INT(height));
+  return self;
+}
+
+static VALUE linechart_clear(VALUE self) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_clear(linechart->handle);
+  return self;
+}
+
+static VALUE linechart_draw_axes(VALUE self) {
+  GET_LINECHART(self, linechart);
+  ntcharts_linechart_draw_axes(linechart->handle);
+  return self;
+}
+
+static VALUE linechart_draw_rune(int argc, VALUE *argv, VALUE self) {
+  GET_LINECHART(self, linechart);
+  VALUE x, y, r, style;
+  rb_scan_args(argc, argv, "31", &x, &y, &r, &style);
+
+  int rune_val;
+
+  if (RB_TYPE_P(r, T_STRING)) {
+    const char *str = StringValueCStr(r);
+    rune_val = (unsigned char)str[0];
+  } else {
+    rune_val = NUM2INT(r);
+  }
+
+  if (NIL_P(style)) {
+    ntcharts_linechart_draw_rune(linechart->handle, NUM2DBL(x), NUM2DBL(y), rune_val);
+  } else {
+    ntcharts_style_t *style_ptr;
+    TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+    ntcharts_linechart_draw_rune_with_style(linechart->handle, NUM2DBL(x), NUM2DBL(y), rune_val, style_ptr->handle);
+  }
+
+  return self;
+}
+
+static VALUE linechart_draw_line(int argc, VALUE *argv, VALUE self) {
+  GET_LINECHART(self, linechart);
+  VALUE x1, y1, x2, y2, line_style, style;
+  rb_scan_args(argc, argv, "42", &x1, &y1, &x2, &y2, &line_style, &style);
+
+  int ls = NIL_P(line_style) ? 0 : NUM2INT(line_style);
+
+  if (NIL_P(style)) {
+    ntcharts_linechart_draw_line(linechart->handle,
+      NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x2), NUM2DBL(y2), ls);
+  } else {
+    ntcharts_style_t *style_ptr;
+    TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+    ntcharts_linechart_draw_line_with_style(linechart->handle,
+      NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x2), NUM2DBL(y2), ls, style_ptr->handle);
+  }
+
+  return self;
+}
+
+static VALUE linechart_draw_braille_line(int argc, VALUE *argv, VALUE self) {
+  GET_LINECHART(self, linechart);
+  VALUE x1, y1, x2, y2, style;
+  rb_scan_args(argc, argv, "41", &x1, &y1, &x2, &y2, &style);
+
+  if (NIL_P(style)) {
+    ntcharts_linechart_draw_braille_line(linechart->handle,
+      NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x2), NUM2DBL(y2));
+  } else {
+    ntcharts_style_t *style_ptr;
+    TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+    ntcharts_linechart_draw_braille_line_with_style(linechart->handle,
+      NUM2DBL(x1), NUM2DBL(y1), NUM2DBL(x2), NUM2DBL(y2), style_ptr->handle);
+  }
+
+  return self;
+}
+
+static VALUE linechart_set_style(VALUE self, VALUE style) {
+  GET_LINECHART(self, linechart);
+  ntcharts_style_t *style_ptr;
+  TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+  ntcharts_linechart_set_style(linechart->handle, style_ptr->handle);
+  return self;
+}
+
+static VALUE linechart_set_axis_style(VALUE self, VALUE style) {
+  GET_LINECHART(self, linechart);
+  ntcharts_style_t *style_ptr;
+  TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+  ntcharts_linechart_set_axis_style(linechart->handle, style_ptr->handle);
+  return self;
+}
+
+static VALUE linechart_set_label_style(VALUE self, VALUE style) {
+  GET_LINECHART(self, linechart);
+  ntcharts_style_t *style_ptr;
+  TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+  ntcharts_linechart_set_label_style(linechart->handle, style_ptr->handle);
+  return self;
+}
+
+static VALUE linechart_view(VALUE self) {
+  GET_LINECHART(self, linechart);
+  char *result = ntcharts_linechart_view(linechart->handle);
+  VALUE rb_result = rb_utf8_str_new_cstr(result);
+  ntcharts_free(result);
+  return rb_result;
+}
+
+static VALUE linechart_to_s(VALUE self) {
+  return linechart_view(self);
+}
+
+void Init_ntcharts_linechart(void) {
+  cLinechart = rb_define_class_under(mNtcharts, "Linechart", rb_cObject);
+
+  rb_define_alloc_func(cLinechart, linechart_alloc);
+  rb_define_method(cLinechart, "initialize", linechart_initialize, -1);
+
+  rb_define_method(cLinechart, "width", linechart_width, 0);
+  rb_define_method(cLinechart, "height", linechart_height, 0);
+  rb_define_method(cLinechart, "graph_width", linechart_graph_width, 0);
+  rb_define_method(cLinechart, "graph_height", linechart_graph_height, 0);
+
+  rb_define_method(cLinechart, "min_x", linechart_min_x, 0);
+  rb_define_method(cLinechart, "max_x", linechart_max_x, 0);
+  rb_define_method(cLinechart, "min_y", linechart_min_y, 0);
+  rb_define_method(cLinechart, "max_y", linechart_max_y, 0);
+  rb_define_method(cLinechart, "view_min_x", linechart_view_min_x, 0);
+  rb_define_method(cLinechart, "view_max_x", linechart_view_max_x, 0);
+  rb_define_method(cLinechart, "view_min_y", linechart_view_min_y, 0);
+  rb_define_method(cLinechart, "view_max_y", linechart_view_max_y, 0);
+
+  rb_define_method(cLinechart, "x_step", linechart_x_step, 0);
+  rb_define_method(cLinechart, "y_step", linechart_y_step, 0);
+  rb_define_method(cLinechart, "x_step=", linechart_set_x_step, 1);
+  rb_define_method(cLinechart, "y_step=", linechart_set_y_step, 1);
+
+  rb_define_method(cLinechart, "set_x_range", linechart_set_x_range, 2);
+  rb_define_method(cLinechart, "set_y_range", linechart_set_y_range, 2);
+  rb_define_method(cLinechart, "set_view_x_range", linechart_set_view_x_range, 2);
+  rb_define_method(cLinechart, "set_view_y_range", linechart_set_view_y_range, 2);
+  rb_define_method(cLinechart, "set_auto_x_range", linechart_set_auto_x_range, 2);
+  rb_define_method(cLinechart, "set_auto_y_range", linechart_set_auto_y_range, 2);
+
+  rb_define_method(cLinechart, "resize", linechart_resize, 2);
+  rb_define_method(cLinechart, "clear", linechart_clear, 0);
+  rb_define_method(cLinechart, "draw_axes", linechart_draw_axes, 0);
+
+  rb_define_method(cLinechart, "draw_rune", linechart_draw_rune, -1);
+  rb_define_method(cLinechart, "draw_line", linechart_draw_line, -1);
+  rb_define_method(cLinechart, "draw_braille_line", linechart_draw_braille_line, -1);
+
+  rb_define_method(cLinechart, "_set_style", linechart_set_style, 1);
+  rb_define_method(cLinechart, "_set_axis_style", linechart_set_axis_style, 1);
+  rb_define_method(cLinechart, "_set_label_style", linechart_set_label_style, 1);
+
+  rb_define_method(cLinechart, "view", linechart_view, 0);
+  rb_define_method(cLinechart, "to_s", linechart_to_s, 0);
+
+  rb_define_const(cLinechart, "LINE_STYLE_THIN", INT2NUM(0));
+  rb_define_const(cLinechart, "LINE_STYLE_ARC", INT2NUM(1));
+}

data/ext/ntcharts/sparkline.c

@@ -0,0 +1,161 @@
+#include "extension.h"
+
+static void sparkline_free(void *pointer) {
+  ntcharts_sparkline_t *sparkline = (ntcharts_sparkline_t *)pointer;
+  if (sparkline->handle != 0) {
+    ntcharts_sparkline_free(sparkline->handle);
+  }
+  xfree(sparkline);
+}
+
+static size_t sparkline_memsize(const void *pointer) {
+  return sizeof(ntcharts_sparkline_t);
+}
+
+const rb_data_type_t sparkline_type = {
+  .wrap_struct_name = "Ntcharts::Sparkline",
+  .function = {
+    .dmark = NULL,
+    .dfree = sparkline_free,
+    .dsize = sparkline_memsize,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE sparkline_alloc(VALUE klass) {
+  ntcharts_sparkline_t *sparkline = ALLOC(ntcharts_sparkline_t);
+  sparkline->handle = 0;
+  return TypedData_Wrap_Struct(klass, &sparkline_type, sparkline);
+}
+
+VALUE sparkline_wrap(VALUE klass, unsigned long long handle) {
+  ntcharts_sparkline_t *sparkline = ALLOC(ntcharts_sparkline_t);
+  sparkline->handle = handle;
+  return TypedData_Wrap_Struct(klass, &sparkline_type, sparkline);
+}
+
+static VALUE sparkline_initialize(VALUE self, VALUE width, VALUE height) {
+  GET_SPARKLINE(self, sparkline);
+  sparkline->handle = ntcharts_sparkline_new(NUM2INT(width), NUM2INT(height));
+  return self;
+}
+
+static VALUE sparkline_width(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  return INT2NUM(ntcharts_sparkline_width(sparkline->handle));
+}
+
+static VALUE sparkline_height(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  return INT2NUM(ntcharts_sparkline_height(sparkline->handle));
+}
+
+static VALUE sparkline_max_value(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  return DBL2NUM(ntcharts_sparkline_max_value(sparkline->handle));
+}
+
+static VALUE sparkline_scale(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  return DBL2NUM(ntcharts_sparkline_scale(sparkline->handle));
+}
+
+static VALUE sparkline_set_max(VALUE self, VALUE max_val) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_set_max(sparkline->handle, NUM2DBL(max_val));
+  return self;
+}
+
+static VALUE sparkline_set_style(VALUE self, VALUE style) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_style_t *style_ptr;
+  TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+  ntcharts_sparkline_set_style(sparkline->handle, style_ptr->handle);
+  return self;
+}
+
+static VALUE sparkline_set_auto_max_value(VALUE self, VALUE auto_val) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_set_auto_max_value(sparkline->handle, RTEST(auto_val) ? 1 : 0);
+  return self;
+}
+
+static VALUE sparkline_resize(VALUE self, VALUE width, VALUE height) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_resize(sparkline->handle, NUM2INT(width), NUM2INT(height));
+  return self;
+}
+
+static VALUE sparkline_clear(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_clear(sparkline->handle);
+  return self;
+}
+
+static VALUE sparkline_push(VALUE self, VALUE value) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_push(sparkline->handle, NUM2DBL(value));
+  return self;
+}
+
+static VALUE sparkline_push_all(VALUE self, VALUE values) {
+  GET_SPARKLINE(self, sparkline);
+  Check_Type(values, T_ARRAY);
+  VALUE json_str = rb_funcall(values, rb_intern("to_json"), 0);
+  ntcharts_sparkline_push_all(sparkline->handle, StringValueCStr(json_str));
+  return self;
+}
+
+static VALUE sparkline_draw(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_draw(sparkline->handle);
+  return self;
+}
+
+static VALUE sparkline_draw_columns_only(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_draw_columns_only(sparkline->handle);
+  return self;
+}
+
+static VALUE sparkline_draw_braille(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  ntcharts_sparkline_draw_braille(sparkline->handle);
+  return self;
+}
+
+static VALUE sparkline_view(VALUE self) {
+  GET_SPARKLINE(self, sparkline);
+  char *result = ntcharts_sparkline_view(sparkline->handle);
+  VALUE rb_result = rb_utf8_str_new_cstr(result);
+  ntcharts_free(result);
+  return rb_result;
+}
+
+static VALUE sparkline_to_s(VALUE self) {
+  return sparkline_view(self);
+}
+
+void Init_ntcharts_sparkline(void) {
+  cSparkline = rb_define_class_under(mNtcharts, "Sparkline", rb_cObject);
+
+  rb_define_alloc_func(cSparkline, sparkline_alloc);
+
+  rb_define_method(cSparkline, "initialize", sparkline_initialize, 2);
+  rb_define_method(cSparkline, "width", sparkline_width, 0);
+  rb_define_method(cSparkline, "height", sparkline_height, 0);
+  rb_define_method(cSparkline, "max_value", sparkline_max_value, 0);
+  rb_define_method(cSparkline, "scale", sparkline_scale, 0);
+  rb_define_method(cSparkline, "max=", sparkline_set_max, 1);
+  rb_define_method(cSparkline, "_set_style", sparkline_set_style, 1);
+  rb_define_method(cSparkline, "auto_max_value=", sparkline_set_auto_max_value, 1);
+  rb_define_method(cSparkline, "resize", sparkline_resize, 2);
+  rb_define_method(cSparkline, "clear", sparkline_clear, 0);
+  rb_define_method(cSparkline, "push", sparkline_push, 1);
+  rb_define_method(cSparkline, "push_all", sparkline_push_all, 1);
+  rb_define_method(cSparkline, "draw", sparkline_draw, 0);
+  rb_define_method(cSparkline, "draw_columns_only", sparkline_draw_columns_only, 0);
+  rb_define_method(cSparkline, "draw_braille", sparkline_draw_braille, 0);
+  rb_define_method(cSparkline, "view", sparkline_view, 0);
+  rb_define_method(cSparkline, "to_s", sparkline_to_s, 0);
+}