ntcharts 0.1.0-aarch64-linux-musl

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 976a981a6630e3686a14c03f7ae85dd9477cf9e333e50907deb5a29beed4c86c
+  data.tar.gz: 32fc0b94ffda93f98f1f2ec1d17fb556b9c6dc90b15fb244820ae7d0feee4821
+SHA512:
+  metadata.gz: 1d712dfd3d4d4feb126071379edc24a6a2da3fbc2fcffd56977686daf6bc888d264db671bd8b572133055190c3bd423c6c2d32e8561eaf98bfa1b001a5468f41
+  data.tar.gz: 5fd5a23a0cb5bfaee54534f5a6badc60107c5b6f3a3d21ebde21159679ff58f742ce446554735d5a1da7fbbb2d5504af9f0049edc653c4432544622e9e276a74

data/README.md

@@ -0,0 +1,332 @@
+<div align="center">
+  <h1>Nimble Terminal Charts for Ruby</h1>
+  <h4>Terminal Charts for Beautiful Data Visualization</h4>
+
+  <p>
+    <a href="https://rubygems.org/gems/ntcharts"><img alt="Gem Version" src="https://img.shields.io/gem/v/ntcharts"></a>
+    <a href="https://github.com/marcoroth/ntcharts-ruby/blob/main/LICENSE.txt"><img alt="License" src="https://img.shields.io/github/license/marcoroth/ntcharts-ruby"></a>
+  </p>
+
+  <p>Ruby bindings for <a href="https://github.com/NimbleMarkets/ntcharts">NimbleMarkets/ntcharts</a>.<br/>Render beautiful charts directly in your terminal. Built with TUIs in mind.</p>
+</div>
+
+## Installation
+
+**Add to your Gemfile:**
+
+```ruby
+gem "ntcharts"
+```
+
+**Or install directly:**
+
+```bash
+gem install ntcharts
+```
+
+## Usage
+
+### Sparkline
+
+**Compact time-series visualization:**
+
+```ruby
+require "ntcharts"
+
+chart = Ntcharts::Sparkline.new(40, 6)
+[1, 4, 2, 7, 3, 9, 5, 8, 2, 6].each { |v| chart.push(v) }
+chart.draw
+puts chart.view
+```
+
+**Styled sparkline with lipgloss:**
+
+```ruby
+require "lipgloss"
+
+style = Lipgloss::Style.new.foreground("#FF6B6B")
+chart = Ntcharts::Sparkline.new(40, 6)
+chart.style = style  # Accepts Lipgloss::Style or Ntcharts::Style
+
+[5, 3, 7, 2, 9, 4, 6, 1, 8, 3].each { |v| chart.push(v) }
+chart.draw_braille
+puts chart.view
+```
+
+### Barchart
+
+**Horizontal and vertical bar charts:**
+
+```ruby
+chart = Ntcharts::Barchart.new(50, 12)
+
+chart.push(label: "Go", values: [{ value: 85, style: style }])
+chart.push(label: "Ruby", values: [{ value: 92, style: style }])
+chart.push(label: "Python", values: [{ value: 78, style: style }])
+
+puts chart.render
+```
+
+**Stacked bar segments:**
+
+```ruby
+chart.push(
+  label: "Sales",
+  values: [
+    { value: 30, style: red_style },
+    { value: 45, style: green_style },
+    { value: 25, style: blue_style }
+  ]
+)
+```
+
+### LineChart
+
+**X/Y coordinate plotting:**
+
+```ruby
+chart = Ntcharts::Linechart.new(50, 12, 0.0, 10.0, 0.0, 10.0)
+
+(0..10).each do |i|
+  x = i.to_f
+  y = Math.sin(i * 0.5) * 4 + 5
+  chart.draw_rune(x, y, "*")
+end
+
+chart.draw_axes
+puts chart.view
+```
+
+**Braille lines for smooth curves:**
+
+```ruby
+chart = Ntcharts::Linechart.new(60, 15, 0.0, 30.0, -5.0, 10.0)
+
+points = (0..30).map { |i| [i.to_f, Math.sin(i * 0.2) * 4 + 3] }
+
+points.each_cons(2) do |(x1, y1), (x2, y2)|
+  chart.draw_braille_line(x1, y1, x2, y2)
+end
+
+chart.draw_axes
+puts chart.view
+```
+
+#### Line styles
+
+**Thin lines (box-drawing characters)**
+
+```ruby
+chart.draw_line(0, 0, 10, 10, Ntcharts::Linechart::LINE_STYLE_THIN)
+```
+
+**Arc lines (curved connections)**
+```ruby
+chart.draw_line(0, 0, 10, 10, Ntcharts::Linechart::LINE_STYLE_ARC)
+```
+
+### WaveLineChart
+
+**Multiple named datasets:**
+
+```ruby
+chart = Ntcharts::Wavelinechart.new(60, 15)
+
+(0..40).each { |i| chart.plot(i.to_f, Math.sin(i * 0.15) * 5 + 5) }
+
+(0..40).each do |i|
+  chart.plot_data_set("series_a", i.to_f, Math.cos(i * 0.15) * 4 + 5)
+  chart.plot_data_set("series_b", i.to_f, Math.sin(i * 0.1) * 3 + 5)
+end
+
+chart.draw_all
+puts chart.view
+```
+
+### StreamLineChart
+
+**Real-time scrolling data:**
+
+```ruby
+chart = Ntcharts::Streamlinechart.new(60, 12)
+chart.style = Lipgloss::Style.new.foreground("#00D4FF")
+
+loop do
+  value = Math.sin(Time.now.to_f) * 4 + 5
+  chart.push(value)
+
+  system("clear")
+  puts chart.render
+  sleep 0.1
+end
+```
+
+### TimeSeriesLineChart
+
+**Time-based X-axis with date labels:**
+
+```ruby
+chart = Ntcharts::Timeserieslinechart.new(70, 15)
+
+now = Time.now
+(0..60).each do |i|
+  time = now - (60 - i) * 60
+  value = Math.sin(i * 0.1) * 10 + 50
+  chart.push(time, value)
+end
+
+chart.draw_braille
+puts chart.view
+```
+
+### Styling
+
+**All charts support lipgloss styling:**
+
+```ruby
+require "lipgloss"
+
+chart_style = Lipgloss::Style.new.foreground("#FF6B6B")
+axis_style = Lipgloss::Style.new.foreground("#666666")
+label_style = Lipgloss::Style.new.foreground("#888888")
+
+chart.style = chart_style
+chart.axis_style = axis_style
+chart.label_style = label_style
+```
+
+**Or use Ntcharts::Style directly:**
+
+```ruby
+style = Ntcharts::Style.new
+  .foreground("#00FF00")
+  .background("#000033")
+  .bold(true)
+
+chart.style = style
+```
+
+## Chart Types
+
+| Chart | Description | Key Features |
+|-------|-------------|--------------|
+| `Sparkline` | Compact time-series | Column and braille rendering modes |
+| `Barchart` | Bar charts | Horizontal/vertical, stacked segments |
+| `Linechart` | Base X/Y plotting | Points, lines, braille, custom runes |
+| `Wavelinechart` | Multi-dataset lines | Named datasets, arc/thin line styles |
+| `Streamlinechart` | Scrolling streams | Push data, auto-scroll right-to-left |
+| `Timeserieslinechart` | Time-based charts | Ruby Time objects, date labels |
+
+## Sparkline Methods
+
+| Method | Description |
+|--------|-------------|
+| `push(value)` | Add a data point |
+| `draw` | Render with column characters |
+| `draw_braille` | Render with braille dots |
+| `view` | Get rendered string |
+| `style=` | Set chart style |
+| `max=` | Set maximum value |
+| `auto_max_value=` | Enable/disable auto-scaling |
+| `resize(width, height)` | Resize the chart |
+| `clear` | Clear all data |
+
+## Barchart Methods
+
+| Method | Description |
+|--------|-------------|
+| `push(bar_data)` | Add a bar (Hash or BarData) |
+| `push_all(array)` | Add multiple bars |
+| `render` | Draw and return view |
+| `horizontal=` | Set horizontal orientation |
+| `bar_width=` | Set bar width |
+| `bar_gap=` | Set gap between bars |
+| `show_axis=` | Show/hide axis |
+| `axis_style=` | Set axis style |
+| `label_style=` | Set label style |
+
+## LineChart Methods
+
+| Method | Description |
+|--------|-------------|
+| `draw_rune(x, y, char, [style])` | Draw character at point |
+| `draw_line(x1, y1, x2, y2, line_style, [style])` | Draw line segment |
+| `draw_braille_line(x1, y1, x2, y2, [style])` | Draw braille line |
+| `draw_axes` | Draw X and Y axes |
+| `view` | Get rendered string |
+| `set_x_range(min, max)` | Set X data range |
+| `set_y_range(min, max)` | Set Y data range |
+| `x_step=` / `y_step=` | Set axis step (0 to hide) |
+
+## StreamLineChart Methods
+
+| Method | Description |
+|--------|-------------|
+| `push(value)` | Add value (scrolls left) |
+| `render` | Draw and return view |
+| `set_y_range(min, max)` | Set Y range |
+| `style=` | Set line style |
+| `clear_data` | Clear data points |
+
+## TimeSeriesLineChart Methods
+
+| Method | Description |
+|--------|-------------|
+| `push(time, value)` | Add time point |
+| `push_data_set(name, time, value)` | Add to named dataset |
+| `draw` / `draw_all` | Render default/all datasets |
+| `draw_braille` / `draw_braille_all` | Braille rendering |
+| `set_time_range(min, max)` | Set time range |
+| `line_style=` | Set line style (THIN/ARC) |
+
+## Line Style Constants
+
+Available on `Linechart`, `Wavelinechart`, `Streamlinechart`, `Timeserieslinechart`:
+
+| Constant | Description |
+|----------|-------------|
+| `LINE_STYLE_THIN` | Box-drawing characters |
+| `LINE_STYLE_ARC` | Curved arc connections |
+
+## Development
+
+**Requirements:**
+- Go 1.23+
+- Ruby 3.2+
+
+**Install dependencies:**
+
+```bash
+bundle install
+```
+
+**Build the Go library and compile the extension:**
+
+```bash
+bundle exec rake go:build
+bundle exec rake compile
+```
+
+**Run demos:**
+
+```bash
+./demo/sparkline
+./demo/barchart
+./demo/linechart
+./demo/wavelinechart
+./demo/streamlinechart
+./demo/timeserieslinechart
+./demo/streaming
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcoroth/ntcharts-ruby.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.
+
+## Acknowledgments
+
+This gem wraps [NimbleMarkets/ntcharts](https://github.com/NimbleMarkets/ntcharts), which builds on the excellent [Charm](https://charm.sh) ecosystem including [lipgloss](https://github.com/charmbracelet/lipgloss).

data/ext/ntcharts/barchart.c

@@ -0,0 +1,215 @@
+#include "extension.h"
+
+static void barchart_free(void *pointer) {
+  ntcharts_barchart_t *barchart = (ntcharts_barchart_t *)pointer;
+  if (barchart->handle != 0) {
+    ntcharts_barchart_free(barchart->handle);
+  }
+  xfree(barchart);
+}
+
+static size_t barchart_memsize(const void *pointer) {
+  return sizeof(ntcharts_barchart_t);
+}
+
+const rb_data_type_t barchart_type = {
+  .wrap_struct_name = "Ntcharts::Barchart",
+  .function = {
+    .dmark = NULL,
+    .dfree = barchart_free,
+    .dsize = barchart_memsize,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE barchart_alloc(VALUE klass) {
+  ntcharts_barchart_t *barchart = ALLOC(ntcharts_barchart_t);
+  barchart->handle = 0;
+  return TypedData_Wrap_Struct(klass, &barchart_type, barchart);
+}
+
+VALUE barchart_wrap(VALUE klass, unsigned long long handle) {
+  ntcharts_barchart_t *barchart = ALLOC(ntcharts_barchart_t);
+  barchart->handle = handle;
+  return TypedData_Wrap_Struct(klass, &barchart_type, barchart);
+}
+
+static VALUE barchart_initialize(VALUE self, VALUE width, VALUE height) {
+  GET_BARCHART(self, barchart);
+  barchart->handle = ntcharts_barchart_new(NUM2INT(width), NUM2INT(height));
+  return self;
+}
+
+static VALUE barchart_width(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return INT2NUM(ntcharts_barchart_width(barchart->handle));
+}
+
+static VALUE barchart_height(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return INT2NUM(ntcharts_barchart_height(barchart->handle));
+}
+
+static VALUE barchart_max_value(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return DBL2NUM(ntcharts_barchart_max_value(barchart->handle));
+}
+
+static VALUE barchart_scale(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return DBL2NUM(ntcharts_barchart_scale(barchart->handle));
+}
+
+static VALUE barchart_bar_width(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return INT2NUM(ntcharts_barchart_bar_width(barchart->handle));
+}
+
+static VALUE barchart_bar_gap(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return INT2NUM(ntcharts_barchart_bar_gap(barchart->handle));
+}
+
+static VALUE barchart_show_axis_p(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return ntcharts_barchart_show_axis(barchart->handle) ? Qtrue : Qfalse;
+}
+
+static VALUE barchart_horizontal_p(VALUE self) {
+  GET_BARCHART(self, barchart);
+  return ntcharts_barchart_horizontal(barchart->handle) ? Qtrue : Qfalse;
+}
+
+static VALUE barchart_set_max(VALUE self, VALUE max_val) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_max(barchart->handle, NUM2DBL(max_val));
+  return self;
+}
+
+static VALUE barchart_set_bar_width(VALUE self, VALUE width) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_bar_width(barchart->handle, NUM2INT(width));
+  return self;
+}
+
+static VALUE barchart_set_bar_gap(VALUE self, VALUE gap) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_bar_gap(barchart->handle, NUM2INT(gap));
+  return self;
+}
+
+static VALUE barchart_set_horizontal(VALUE self, VALUE horizontal) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_horizontal(barchart->handle, RTEST(horizontal) ? 1 : 0);
+  return self;
+}
+
+static VALUE barchart_set_show_axis(VALUE self, VALUE show_axis) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_show_axis(barchart->handle, RTEST(show_axis) ? 1 : 0);
+  return self;
+}
+
+static VALUE barchart_set_auto_max_value(VALUE self, VALUE auto_max) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_auto_max_value(barchart->handle, RTEST(auto_max) ? 1 : 0);
+  return self;
+}
+
+static VALUE barchart_set_auto_bar_width(VALUE self, VALUE auto_width) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_set_auto_bar_width(barchart->handle, RTEST(auto_width) ? 1 : 0);
+  return self;
+}
+
+static VALUE barchart_set_axis_style(VALUE self, VALUE style) {
+  GET_BARCHART(self, barchart);
+  ntcharts_style_t *style_ptr;
+  TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+  ntcharts_barchart_set_axis_style(barchart->handle, style_ptr->handle);
+  return self;
+}
+
+static VALUE barchart_set_label_style(VALUE self, VALUE style) {
+  GET_BARCHART(self, barchart);
+  ntcharts_style_t *style_ptr;
+  TypedData_Get_Struct(style, ntcharts_style_t, &style_type, style_ptr);
+  ntcharts_barchart_set_label_style(barchart->handle, style_ptr->handle);
+  return self;
+}
+
+static VALUE barchart_resize(VALUE self, VALUE width, VALUE height) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_resize(barchart->handle, NUM2INT(width), NUM2INT(height));
+  return self;
+}
+
+static VALUE barchart_clear(VALUE self) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_clear(barchart->handle);
+  return self;
+}
+
+static VALUE barchart_push(VALUE self, VALUE bar_data) {
+  GET_BARCHART(self, barchart);
+  VALUE json_str = rb_funcall(bar_data, rb_intern("to_json"), 0);
+  ntcharts_barchart_push(barchart->handle, StringValueCStr(json_str));
+  return self;
+}
+
+static VALUE barchart_push_all(VALUE self, VALUE bar_data_array) {
+  GET_BARCHART(self, barchart);
+  Check_Type(bar_data_array, T_ARRAY);
+  VALUE json_str = rb_funcall(bar_data_array, rb_intern("to_json"), 0);
+  ntcharts_barchart_push_all(barchart->handle, StringValueCStr(json_str));
+  return self;
+}
+
+static VALUE barchart_draw(VALUE self) {
+  GET_BARCHART(self, barchart);
+  ntcharts_barchart_draw(barchart->handle);
+  return self;
+}
+
+static VALUE barchart_view(VALUE self) {
+  GET_BARCHART(self, barchart);
+  char *result = ntcharts_barchart_view(barchart->handle);
+  VALUE rb_result = rb_utf8_str_new_cstr(result);
+  ntcharts_free(result);
+  return rb_result;
+}
+
+static VALUE barchart_to_s(VALUE self) {
+  return barchart_view(self);
+}
+
+void Init_ntcharts_barchart(void) {
+  cBarchart = rb_define_class_under(mNtcharts, "Barchart", rb_cObject);
+
+  rb_define_alloc_func(cBarchart, barchart_alloc);
+  rb_define_method(cBarchart, "initialize", barchart_initialize, 2);
+  rb_define_method(cBarchart, "width", barchart_width, 0);
+  rb_define_method(cBarchart, "height", barchart_height, 0);
+  rb_define_method(cBarchart, "max_value", barchart_max_value, 0);
+  rb_define_method(cBarchart, "scale", barchart_scale, 0);
+  rb_define_method(cBarchart, "bar_width", barchart_bar_width, 0);
+  rb_define_method(cBarchart, "bar_gap", barchart_bar_gap, 0);
+  rb_define_method(cBarchart, "show_axis?", barchart_show_axis_p, 0);
+  rb_define_method(cBarchart, "horizontal?", barchart_horizontal_p, 0);
+  rb_define_method(cBarchart, "max=", barchart_set_max, 1);
+  rb_define_method(cBarchart, "bar_width=", barchart_set_bar_width, 1);
+  rb_define_method(cBarchart, "bar_gap=", barchart_set_bar_gap, 1);
+  rb_define_method(cBarchart, "horizontal=", barchart_set_horizontal, 1);
+  rb_define_method(cBarchart, "show_axis=", barchart_set_show_axis, 1);
+  rb_define_method(cBarchart, "auto_max_value=", barchart_set_auto_max_value, 1);
+  rb_define_method(cBarchart, "auto_bar_width=", barchart_set_auto_bar_width, 1);
+  rb_define_method(cBarchart, "_set_axis_style", barchart_set_axis_style, 1);
+  rb_define_method(cBarchart, "_set_label_style", barchart_set_label_style, 1);
+  rb_define_method(cBarchart, "resize", barchart_resize, 2);
+  rb_define_method(cBarchart, "clear", barchart_clear, 0);
+  rb_define_method(cBarchart, "_push", barchart_push, 1);
+  rb_define_method(cBarchart, "_push_all", barchart_push_all, 1);
+  rb_define_method(cBarchart, "draw", barchart_draw, 0);
+  rb_define_method(cBarchart, "view", barchart_view, 0);
+  rb_define_method(cBarchart, "to_s", barchart_to_s, 0);
+}

data/ext/ntcharts/extconf.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+extension_name = "ntcharts"
+
+def detect_platform
+  cpu = RbConfig::CONFIG["host_cpu"]
+  os = RbConfig::CONFIG["host_os"]
+
+  arch = case cpu
+         when /aarch64|arm64/ then "arm64"
+         when /x86_64|amd64/ then "amd64"
+         when /arm/ then "arm"
+         when /i[3-6]86/ then "386"
+         else cpu
+         end
+
+  goos = case os
+         when /darwin/ then "darwin"
+         when /mswin|mingw/ then "windows"
+         else "linux"
+         end
+
+  "#{goos}_#{arch}"
+end
+
+platform = detect_platform
+go_lib_dir = File.expand_path("../../go/build/#{platform}", __dir__)
+
+puts "Looking for Go library in: #{go_lib_dir}"
+
+unless File.exist?(File.join(go_lib_dir, "libntcharts.a"))
+  abort <<~ERROR
+    Could not find libntcharts.a for platform #{platform}
+
+    Please build the Go archive first:
+      cd go && go build -buildmode=c-archive -o build/#{platform}/libntcharts.a .
+
+    Or run:
+      bundle exec rake go:build
+  ERROR
+end
+
+$LDFLAGS << " -L#{go_lib_dir}"
+$INCFLAGS << " -I#{go_lib_dir}"
+
+$LOCAL_LIBS << " #{go_lib_dir}/libntcharts.a"
+
+case RbConfig::CONFIG["host_os"]
+when /darwin/
+  $LDFLAGS << " -framework CoreFoundation -framework Security -framework SystemConfiguration"
+  $LDFLAGS << " -lresolv"
+when /linux/
+  $LDFLAGS << " -lpthread -lm -ldl"
+  $LDFLAGS << " -lresolv" if find_library("resolv", "res_query")
+end
+
+$srcs = [
+  "extension.c",
+  "sparkline.c",
+  "barchart.c",
+  "linechart.c",
+  "wavelinechart.c",
+  "streamlinechart.c",
+  "timeserieslinechart.c",
+  "style.c",
+]
+
+create_makefile("#{extension_name}/#{extension_name}")

data/ext/ntcharts/extension.c

@@ -0,0 +1,44 @@
+#include "extension.h"
+
+VALUE mNtcharts;
+VALUE cSparkline;
+VALUE cBarchart;
+VALUE cLinechart;
+VALUE cWavelinechart;
+VALUE cStreamlinechart;
+VALUE cTimeserieslinechart;
+VALUE cStyle;
+
+static VALUE ntcharts_upstream_version_rb(VALUE self) {
+  char *version = ntcharts_upstream_version();
+  VALUE rb_version = rb_utf8_str_new_cstr(version);
+
+  ntcharts_free(version);
+
+  return rb_version;
+}
+
+static VALUE ntcharts_version_rb(VALUE self) {
+  VALUE gem_version = rb_const_get(self, rb_intern("VERSION"));
+  VALUE upstream_version = ntcharts_upstream_version_rb(self);
+  VALUE format_string = rb_utf8_str_new_cstr("ntcharts v%s (upstream %s) [Go native extension]");
+
+  return rb_funcall(rb_mKernel, rb_intern("sprintf"), 3, format_string, gem_version, upstream_version);
+}
+
+__attribute__((__visibility__("default"))) void Init_ntcharts(void) {
+  rb_require("json");
+
+  mNtcharts = rb_define_module("Ntcharts");
+
+  Init_ntcharts_sparkline();
+  Init_ntcharts_barchart();
+  Init_ntcharts_linechart();
+  Init_ntcharts_wavelinechart();
+  Init_ntcharts_streamlinechart();
+  Init_ntcharts_timeserieslinechart();
+  Init_ntcharts_style();
+
+  rb_define_singleton_method(mNtcharts, "upstream_version", ntcharts_upstream_version_rb, 0);
+  rb_define_singleton_method(mNtcharts, "version", ntcharts_version_rb, 0);
+}