tulirb 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbe761a5276117baa268d4c3ada16a57afe6a0b993a1a689225320336c4c7a89
-  data.tar.gz: adfd35e0f4de82b8d3cdf70d5bbc4188f5e1b312381b18ef65ea254dbfd914bc
+  metadata.gz: 439ab7a08e2ecbe74674156913a01255c008e7e4768821dae21f4ccef2db95a5
+  data.tar.gz: 20df5ea27a9ef2c6a16aae50688b2fab30b3f4c6327ef0213b188642483b1249
 SHA512:
-  metadata.gz: 6ac704550f29551b68d3681b359dbe5029f08a1a0ae57d2c6f049fbaac4d8581591d87f2431aa4253169008948704f2479cd6dc43ae48c7e92daa28f30624b81
-  data.tar.gz: f951e71336d9c3a42d370d801bdedb3846c13a40d9a5ae1a009bff7415b3ed7011a966a3596a00b4cbfa8bd675e9c5f9e4460e83cb1560c39cd9b02391576c0d
+  metadata.gz: '059b4963c53683830ac7c169596ee001e11bab1c8ebf4ec6cd95d95d92bfdc22c7b5f5647b4698d9b2528c381d5089c52ede0084a97e53d7370508416c620284'
+  data.tar.gz: 0edb7138cc91a916ed717aed369115140041491b53a22fc2f2967439cace19bc58771a55b6a91b252c0a8f888d6ba1063b0a7c7145d5ee3e866b8f94c3aaa399

data/.rubocop.yml

@@ -1,6 +1,6 @@
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
   Exclude:
     - ext/tulirb/extconf.rb
     - Gemfile.lock
@@ -22,6 +22,7 @@ Metrics/ClassLength:
   Enabled: false
 Metrics/MethodLength:
   CountAsOne: ['array', 'heredoc', 'method_call']
+  Max: 30
   
 
 Layout/LineLength:

data/CHANGELOG.md

@@ -1,11 +1,19 @@
-## [Unreleased]
+# Tulirb Changelog
 
-## [0.1.0] - 2023-12-31
+## [1.0.0] - 2025-02-24
 
-- Initial release
+- Fix all compiler warnings in C extension and ensure there are no memory leaks.
+- [internal] Added AddressSanitizer to detect memory leaks in the C extension.
+- [internal] Added Dockerfile and docker-compose.yml to run tests in a Linux environment.
 
-## [0.1.1] - 2023-01-22
+## [0.1.1] - 2024-01-22
 
 - Fixed ArgumentError messages in C extension.
 - [interna] Replace metaprogrammed Ruby wrapper methods with explicitly defined methods.
 - [internal] Added tests for wrapper methods.
+
+## [0.1.0] - 2023-12-31
+
+- Initial release
+
+## [Unreleased]

data/Dockerfile

@@ -0,0 +1,10 @@
+ARG RUBY_VERSION=3.4
+FROM registry.docker.com/library/ruby:$RUBY_VERSION-slim AS base
+WORKDIR /tulirb
+COPY . /tulirb
+RUN apt-get update -qq && \
+  apt-get install -y build-essential \
+  git
+RUN bundle install
+CMD [ "/bin/bash" ]
+ENTRYPOINT [ "/bin/bash", "-c" ]

data/README.md

@@ -41,7 +41,11 @@ Find documentation for all indicator functions [here](https://www.rubydoc.info/g
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to compile the C extension, detect memory leaks in the C extension and run tests. [AddressSanitizer](https://github.com/google/sanitizers/wiki/addresssanitizer) is used to detect memory leaks in the C extension but it is only available on Linux. I'll recommend running the `rake` command with Docker to run in a Linux environment. There is a Dockerfile and docker-compose.yml file in the root directory to help with this. You can run `rake` with Docker by executing:
+
+    $ docker compose run tulirb rake
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/Rakefile

@@ -1,5 +1,45 @@
 # frozen_string_literal: true
 
+def windows?
+  RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
+end
+
+def silence_stream(stream)
+  old_stream = stream.dup
+  stream.reopen(File::NULL)
+  stream.sync = true
+  yield
+ensure
+  stream.reopen(old_stream)
+end
+
+def reenable_task_with_prereqs(task_name)
+  task = Rake::Task[task_name]
+  return unless task.already_invoked # Skip if task hasn't run before
+
+  task.prerequisite_tasks.each { |prereq| reenable_task_with_prereqs(prereq) } # Recursively reset prerequisites
+  task.reenable # Reset the main task itself
+end
+
+def detect_memory_leaks!
+  asan_path = `gcc -print-file-name=libasan.so`.strip
+  env = { "LD_PRELOAD" => asan_path }
+  Open3.capture3(env,
+                 "ruby -Ilib:ext -r tulirb -e \"puts Tulirb.ema([[2, 4, 6]], period: 5)\"").tap do |_, error, status|
+    puts("Running memory leak detection with AddressSanitizer")
+    unless status.success?
+      errors = error.split("\n\n").grep(%r{ext/tulirb})
+      if errors.any?
+        elog = "Memory leaks detected in C extension:\n\n"
+        elog += errors.join("\n\n")
+        raise(elog)
+      end
+    end
+
+    puts("No memory leaks detected in C extension")
+  end
+end
+
 require("bundler/gem_tasks")
 require("rake/testtask")
 
@@ -10,15 +50,30 @@ Rake::TestTask.new(:test) do |t|
 end
 
 require("rubocop/rake_task")
-
 RuboCop::RakeTask.new
 
 require("rake/extensiontask")
-
 task(build: :compile)
-
 Rake::ExtensionTask.new("tulirb") do |ext|
   ext.lib_dir = "lib/tulirb"
 end
 
-task(default: %i[clobber compile test rubocop])
+task(detect_memory_leaks: :clobber) do
+  next if windows?
+
+  require("open3")
+  ENV["SANITIZE"] = "true"
+  silence_stream($stderr) { Rake::Task["compile"].invoke }
+
+  begin
+    detect_memory_leaks!
+  ensure
+    reenable_task_with_prereqs("clobber")
+    Rake::Task["clobber"].invoke
+    ENV["SANITIZE"] = "false"
+    reenable_task_with_prereqs("clobber")
+    reenable_task_with_prereqs("compile")
+  end
+end
+
+task(default: %i[detect_memory_leaks compile test rubocop clobber])

data/docker-compose.yml

@@ -0,0 +1,8 @@
+version: '3.4'
+
+services:
+  tulirb:
+    platform: linux/amd64
+    build: .
+    volumes:
+      - .:/tulirb

data/ext/tulirb/extconf.rb

@@ -2,8 +2,12 @@
 
 require "mkmf"
 
-# $LDFLAGS << " -fsanitize=address,undefined"
-# $CFLAGS << " -fsanitize=address,undefined"
+if ENV["SANITIZE"] == "true"
+  CONFIG["optflags"] = "-O0"
+  CONFIG["debugflags"] = "-ggdb3"
+  $CFLAGS << " -fsanitize=address -fno-omit-frame-pointer -fno-optimize-sibling-calls -DTULIRB_SANITIZE=1"
+  $LDFLAGS << " -fsanitize=address -fno-omit-frame-pointer -fno-optimize-sibling-calls"
+end
 
 $srcs = %w[tiamalgamation.c tulirb.c]
 create_makefile("tulirb/tulirb")

data/ext/tulirb/tulirb.c

@@ -1,8 +1,16 @@
 #include "tulirb.h"
 
-static void xfree_ptr_arr(TI_REAL **, size_t);
+#ifdef TULIRB_SANITIZE
+#define TULIRB_MALLOC(size) malloc(size)
+#define TULIRB_FREE(ptr) free(ptr)
+#else
+#define TULIRB_MALLOC(size) xmalloc(size)
+#define TULIRB_FREE(ptr) xfree(ptr)
+#endif
 
-static inline VALUE ti_wrapper(VALUE inputs, VALUE opts, char *indicator_name)
+static inline void xfree_ptr_arr(TI_REAL **, size_t);
+
+static inline VALUE ti_wrapper(VALUE inputs, VALUE opts, const char *indicator_name)
 {
   Check_Type(inputs, T_ARRAY);
   Check_Type(opts, T_ARRAY);
@@ -18,9 +26,9 @@ static inline VALUE ti_wrapper(VALUE inputs, VALUE opts, char *indicator_name)
     rb_raise(rb_eArgError, "Invalid options size, expected: %i options", indicator->options);
   }
 
-  TI_REAL *options = (TI_REAL *)xmalloc(sizeof(TI_REAL[RARRAY_LEN(opts)]));
+  TI_REAL *options = (TI_REAL *)TULIRB_MALLOC(sizeof(TI_REAL[RARRAY_LEN(opts)]));
 
-  for (size_t i = 0; i < RARRAY_LEN(opts); i++)
+  for (int i = 0; i < RARRAY_LEN(opts); i++)
     options[i] = NUM2DBL(rb_ary_entry(opts, i));
 
   const int start = indicator->start(options);
@@ -31,26 +39,26 @@ static inline VALUE ti_wrapper(VALUE inputs, VALUE opts, char *indicator_name)
   if (output_length < 0)
     return Qnil;
 
-  TI_REAL **c_inputs = xmalloc(indicator->inputs * sizeof(TI_REAL *));
-  for (size_t i = 0; i < indicator->inputs; i++)
+  TI_REAL **c_inputs = TULIRB_MALLOC(indicator->inputs * sizeof(TI_REAL *));
+  for (int i = 0; i < indicator->inputs; i++)
   {
-    TI_REAL *c_entry = xmalloc(sizeof(TI_REAL[size]));
+    TI_REAL *c_entry = TULIRB_MALLOC(sizeof(TI_REAL[size]));
     VALUE entry = rb_ary_entry(inputs, i);
-    for (size_t j = 0; j < size; j++)
+    for (int j = 0; j < size; j++)
     {
       c_entry[j] = NUM2DBL(rb_ary_entry(entry, j));
     }
     c_inputs[i] = c_entry;
   }
 
-  TI_REAL **outputs = xmalloc(indicator->outputs * sizeof(TI_REAL *));
-  for (size_t i = 0; i < indicator->outputs; i++)
-    outputs[i] = xmalloc(sizeof(TI_REAL[output_length]));
+  TI_REAL **outputs = TULIRB_MALLOC(indicator->outputs * sizeof(TI_REAL *));
+  for (int i = 0; i < indicator->outputs; i++)
+    outputs[i] = TULIRB_MALLOC(sizeof(TI_REAL[output_length]));
 
   int error = indicator->indicator(size, (const TI_REAL *const *)c_inputs, options, outputs);
 
   xfree_ptr_arr(c_inputs, indicator->inputs);
-  xfree(options);
+  TULIRB_FREE(options);
 
   if (error == TI_INVALID_OPTION)
   {
@@ -62,7 +70,7 @@ static inline VALUE ti_wrapper(VALUE inputs, VALUE opts, char *indicator_name)
   for (int i = 0; i < indicator->outputs; i++)
   {
     VALUE output = rb_ary_new_capa(output_length);
-    for (size_t j = 0; j < output_length; j++)
+    for (int j = 0; j < output_length; j++)
     {
       rb_ary_push(output, DBL2NUM(outputs[i][j]));
     }
@@ -73,11 +81,11 @@ static inline VALUE ti_wrapper(VALUE inputs, VALUE opts, char *indicator_name)
   return ret;
 }
 
-static void xfree_ptr_arr(TI_REAL **ptr, size_t size)
+static inline void xfree_ptr_arr(TI_REAL **ptr, size_t size)
 {
-  for (int i = 0; i < size; i++)
-    xfree(ptr[i]);
-  xfree(ptr);
+  for (size_t i = 0; i < size; i++)
+    TULIRB_FREE(ptr[i]);
+  TULIRB_FREE(ptr);
 }
 
 // Alphabetical order
@@ -607,7 +615,7 @@ static inline VALUE parameterize(char *str)
   return rb_funcall(rb_str_new2(str), rb_intern("gsub"), 2, rb_str_new2(" "), rb_str_new2("_"));
 }
 
-static inline VALUE rb_indicators_info()
+static inline VALUE rb_indicators_info(void)
 {
   VALUE ret = rb_hash_new();
   for (size_t i = 0; i < TI_INDICATOR_COUNT; i++)
@@ -632,7 +640,7 @@ static inline VALUE rb_indicators_info()
     };
     rb_hash_aset(ret, ID2SYM(rb_intern(indicator.name)), indicators_hash);
   }
-  return ret;
+  return rb_obj_freeze(ret);
 };
 
 void Init_tulirb(void)

data/lib/tulirb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tulirb
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/tulirb.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
   DESCRIPTION
   spec.homepage = "https://github.com/ozone4real/tulirb"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/ozone4real/tulirb"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tulirb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Ezenwa Ogbonna
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-22 00:00:00.000000000 Z
+date: 2025-02-24 00:00:00.000000000 Z
 dependencies: []
 description: "    Robust technical analysis indicator library for Ruby. \n    Build
   tools for financial trading, data analytics, e.t.c in Ruby\n"
@@ -22,11 +22,13 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - code_generator.rb
+- docker-compose.yml
 - ext/tulirb/extconf.rb
 - ext/tulirb/tiamalgamation.c
 - ext/tulirb/tulirb.c
@@ -50,7 +52,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="