ta_lib_ffi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3fd4ceb928f6fc7a08af545db5e373e3243e308a6340a4b4b323988f01d8bf3
+  data.tar.gz: 05bde454be698fa4d1fbdaac36fb13378651219f78ede4b7fc3b7433cf8fae3f
+SHA512:
+  metadata.gz: 5f78a80b04c9d0c8fe70047337a8b8a5674adb70a6148e418b6548afcad1025929cd63fdf6d904e5d26fbe501c596003680615154ac6e954512e19f887e84eca
+  data.tar.gz: 265fd54ed815b7750091151e4c0256076a122734169a1c7923b9810ea739dc691bf36cb5d1c6bc39f7cfc048efef874ef9fc1718aa98bb20b42720d2162e8c1e

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2024-01-21
+
+### Added
+- Initial release of ta_lib_ffi
+- Basic FFI wrapper for TA-Lib
+- Cross-platform support:
+  - Windows (64-bit)
+  - macOS (via Homebrew)
+  - Linux (Debian/Ubuntu packages)
+- Automated tests with GitHub Actions
+- Basic documentation and usage examples
+
+### Changed
+- N/A
+
+### Deprecated
+- N/A
+
+### Removed
+- N/A
+
+### Fixed
+- N/A
+
+### Security
+- N/A
+
+[0.1.0]: https://github.com/Youngv/ta_lib_ffi/releases/tag/v0.1.0

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Victor Yang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# TALib
+
+![Tests](https://github.com/Youngv/ta_lib_ffi/actions/workflows/main.yml/badge.svg)
+
+## Introduction
+
+TALib is a Ruby binding for [TA-Lib](https://ta-lib.org/) (Technical Analysis Library) using FFI (Foreign Function Interface). It provides a comprehensive set of functions for technical analysis of financial market data.
+
+## Requirements
+
+- Ruby >= 3.0.0
+- TA-Lib >= 0.6.4
+
+## Installation
+
+### [Install TA-Lib](https://ta-lib.org/install/)
+
+#### Windows
+Download and run the installer: [ta-lib-0.6.4-windows-x86_64.msi](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.msi)
+
+#### macOS
+```bash
+brew install ta-lib
+```
+
+#### Linux (Debian/Ubuntu)
+```bash
+# For Intel/AMD 64-bit
+wget https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib_0.6.4_amd64.deb
+sudo dpkg -i ta-lib_0.6.4_amd64.deb
+
+# For ARM64
+wget https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib_0.6.4_arm64.deb
+sudo dpkg -i ta-lib_0.6.4_arm64.deb
+
+# For Intel/AMD 32-bits
+wget https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib_0.6.4_i386.deb
+sudo dpkg -i ta-lib_0.6.4_i386.deb
+```
+
+### Installing the Ruby Gem
+
+Add this to your application's Gemfile:
+
+```ruby
+gem 'ta_lib_ffi'
+```
+
+Then execute:
+
+    $ bundle install
+
+Or install it directly:
+
+    $ gem install ta_lib_ffi
+
+## Usage
+
+```ruby
+require 'ta_lib'
+
+# Initialize data
+prices = [10.0, 11.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0]
+
+# Calculate SMA
+puts TALib.sma(prices, time_period: 3)
+# => [11.0, 11.333333333333334, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0]
+```
+
+## TODO
+- [ ] Add RDoc documentation for Ruby methods
+- [ ] Create detailed function examples with input/output samples
+- [ ] Add more tests for each function
+- [ ] Support custom TA-Lib installation location
+
+## Development
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -am 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Create a Pull Request
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Youngv/ta_lib_ffi
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](LICENSE).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/ta_lib.rb

@@ -0,0 +1,647 @@
+# frozen_string_literal: true
+
+require "fiddle"
+require "fiddle/import"
+
+# Ruby FFI wrapper for TA-Lib (Technical Analysis Library)
+module TALib
+  VERSION = "0.1.0"
+
+  extend Fiddle::Importer
+
+  lib_path = case RUBY_PLATFORM
+             when /darwin/
+               brew_prefix = `brew --prefix`.chomp
+               "#{brew_prefix}/lib/libta-lib.dylib"
+             when /linux/
+               "libta-lib.so"
+             when /cygwin|mswin|mingw|bccwin|wince|emx/
+               "C:/Program Files/TA-Lib/bin/ta-lib.dll"
+             else
+               raise "Unsupported platform"
+             end
+
+  dlload lib_path
+
+  class TALibError < StandardError; end
+
+  TA_SUCCESS                    = 0
+  TA_LIB_NOT_INITIALIZE         = 1
+  TA_BAD_PARAM                  = 2
+  TA_ALLOC_ERR                  = 3
+  TA_GROUP_NOT_FOUND            = 4
+  TA_FUNC_NOT_FOUND             = 5
+  TA_INVALID_HANDLE             = 6
+  TA_INVALID_PARAM_HOLDER       = 7
+  TA_INVALID_PARAM_HOLDER_TYPE  = 8
+  TA_INVALID_PARAM_FUNCTION     = 9
+  TA_INPUT_NOT_ALL_INITIALIZE   = 10
+  TA_OUTPUT_NOT_ALL_INITIALIZE  = 11
+  TA_OUT_OF_RANGE_START_INDEX   = 12
+  TA_OUT_OF_RANGE_END_INDEX     = 13
+  TA_INVALID_LIST_TYPE          = 14
+  TA_BAD_OBJECT                 = 15
+  TA_NOT_SUPPORTED              = 16
+  TA_INTERNAL_ERROR             = 5000
+  TA_UNKNOWN_ERR                = 0xFFFF
+
+  # {0,"SMA"},
+  # {1,"EMA"},
+  # {2,"WMA"},
+  # {3,"DEMA" },
+  # {4,"TEMA" },
+  # {5,"TRIMA"},
+  # {6,"KAMA" },
+  # {7,"MAMA" },
+  # {8,"T3"}
+
+  typealias "TA_Real", "double"
+  typealias "TA_Integer", "int"
+  typealias "TA_RetCode", "int"
+  typealias "TA_FuncHandle", "unsigned int"
+  typealias "TA_FuncFlags", "int"
+  typealias "TA_CallForEachFunc", "void *"
+  typealias "TA_InputParameterType", "int"
+  typealias "TA_InputFlags", "int"
+  typealias "TA_OptInputParameterType", "int"
+  typealias "TA_OptInputFlags", "int"
+  typealias "TA_OutputParameterType", "int"
+  typealias "TA_OutputFlags", "int"
+
+  TA_StringTable = struct [
+    "unsigned int size",
+    "const char **string",
+    "void *hiddenData"
+  ]
+
+  TA_FuncInfo = struct [
+    "const char *name",
+    "const char *group",
+    "const char *hint",
+    "const char *camelCaseName",
+    "TA_FuncFlags flags",
+    "unsigned int nbInput",
+    "unsigned int nbOptInput",
+    "unsigned int nbOutput",
+    "const TA_FuncHandle *handle"
+  ]
+
+  TA_ParamHolder = struct [
+    "void *hiddenData"
+  ]
+
+  TA_InputParameterInfo = struct [
+    "TA_InputParameterType type",
+    "const char *paramName",
+    "TA_InputFlags flags"
+  ]
+
+  TA_OptInputParameterInfo = struct [
+    "TA_OptInputParameterType type",
+    "const char *paramName",
+    "TA_OptInputFlags flags",
+    "const char *displayName",
+    "const void *dataSet",
+    "TA_Real defaultValue",
+    "const char *hint",
+    "const char *helpFile"
+  ]
+
+  TA_OutputParameterInfo = struct [
+    "TA_OutputParameterType type",
+    "const char *paramName",
+    "TA_OutputFlags flags"
+  ]
+
+  TA_PARAM_TYPE = {
+    TA_Input_Price: 0,
+    TA_Input_Real: 1,
+    TA_Input_Integer: 2,
+    TA_OptInput_RealRange: 0,
+    TA_OptInput_RealList: 1,
+    TA_OptInput_IntegerRange: 2,
+    TA_OptInput_IntegerList: 3,
+    TA_Output_Real: 0,
+    TA_Output_Integer: 1
+  }.freeze
+
+  TA_FLAGS = {
+    TA_InputFlags: {
+      TA_IN_PRICE_OPEN: 0x00000001,
+      TA_IN_PRICE_HIGH: 0x00000002,
+      TA_IN_PRICE_LOW: 0x00000004,
+      TA_IN_PRICE_CLOSE: 0x00000008,
+      TA_IN_PRICE_VOLUME: 0x00000010,
+      TA_IN_PRICE_OPENINTEREST: 0x00000020,
+      TA_IN_PRICE_TIMESTAMP: 0x00000040
+    },
+    TA_OptInputFlags: {
+      TA_OPTIN_IS_PERCENT: 0x00100000,
+      TA_OPTIN_IS_DEGREE: 0x00200000,
+      TA_OPTIN_IS_CURRENCY: 0x00400000,
+      TA_OPTIN_ADVANCED: 0x01000000
+    },
+    TA_OutputFlags: {
+      TA_OUT_LINE: 0x00000001,
+      TA_OUT_DOT_LINE: 0x00000002,
+      TA_OUT_DASH_LINE: 0x00000004,
+      TA_OUT_DOT: 0x00000008,
+      TA_OUT_HISTO: 0x00000010,
+      TA_OUT_PATTERN_BOOL: 0x00000020,
+      TA_OUT_PATTERN_BULL_BEAR: 0x00000040,
+      TA_OUT_PATTERN_STRENGTH: 0x00000080,
+      TA_OUT_POSITIVE: 0x00000100,
+      TA_OUT_NEGATIVE: 0x00000200,
+      TA_OUT_ZERO: 0x00000400,
+      TA_OUT_UPPER_LIMIT: 0x00000800,
+      TA_OUT_LOWER_LIMIT: 0x00001000
+    }
+  }.freeze
+
+  extern "int TA_Initialize()"
+  extern "int TA_Shutdown()"
+  extern "int TA_GroupTableAlloc(TA_StringTable**)"
+  extern "int TA_GroupTableFree(TA_StringTable*)"
+  extern "TA_RetCode TA_FuncTableAlloc(const char *group, TA_StringTable **table)"
+  extern "TA_RetCode TA_FuncTableFree(TA_StringTable *table)"
+  extern "TA_FuncHandle TA_GetFuncHandle(const char *name, const TA_FuncHandle **handle)"
+  extern "TA_RetCode TA_GetFuncInfo(const TA_FuncHandle *handle, const TA_FuncInfo **funcInfo)"
+  extern "TA_RetCode TA_ForEachFunc(TA_CallForEachFunc functionToCall, void *opaqueData)"
+  extern "TA_RetCode TA_GetInputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_InputParameterInfo **info)"
+  extern "TA_RetCode TA_GetOptInputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_OptInputParameterInfo **info)"
+  extern "TA_RetCode TA_GetOutputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_OutputParameterInfo **info)"
+  extern "TA_RetCode TA_ParamHolderAlloc(const TA_FuncHandle *handle, TA_ParamHolder **allocatedParams)"
+  extern "TA_RetCode TA_ParamHolderFree(TA_ParamHolder *params)"
+  extern "TA_RetCode TA_SetInputParamIntegerPtr(TA_ParamHolder *params, unsigned int paramIndex, const TA_Integer *value)"
+  extern "TA_RetCode TA_SetInputParamRealPtr(TA_ParamHolder *params, unsigned int paramIndex, const TA_Real *value)"
+  extern "TA_RetCode TA_SetInputParamPricePtr(TA_ParamHolder *params,
+                                             unsigned int paramIndex,
+                                             const TA_Real *open,
+                                             const TA_Real *high,
+                                             const TA_Real *low,
+                                             const TA_Real *close,
+                                             const TA_Real *volume,
+                                             const TA_Real *openInterest)"
+  extern "TA_RetCode TA_SetOptInputParamInteger(TA_ParamHolder *params, unsigned int paramIndex, TA_Integer optInValue)"
+  extern "TA_RetCode TA_SetOptInputParamReal(TA_ParamHolder *params, unsigned int paramIndex, TA_Real optInValue)"
+  extern "TA_RetCode TA_SetOutputParamIntegerPtr(TA_ParamHolder *params, unsigned int paramIndex, TA_Integer *out)"
+  extern "TA_RetCode TA_SetOutputParamRealPtr(TA_ParamHolder *params, unsigned int paramIndex, TA_Real *out)"
+  extern "TA_RetCode TA_GetLookback(const TA_ParamHolder *params, TA_Integer *lookback)"
+  extern "TA_RetCode TA_CallFunc(const TA_ParamHolder *params,
+                                TA_Integer startIdx,
+                                TA_Integer endIdx,
+                                TA_Integer *outBegIdx,
+                                TA_Integer *outNbElement)"
+  extern "const char *TA_FunctionDescriptionXML(void)"
+
+  module_function
+
+  def extract_flags(value, type)
+    flags_set = []
+    TA_FLAGS[type].each do |k, v|
+      flags_set << k if (value & v) != 0
+    end
+    flags_set
+  end
+
+  def group_table
+    string_table_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    ret_code = TA_GroupTableAlloc(string_table_ptr.ref)
+    check_ta_return_code(ret_code)
+
+    string_table = TA_StringTable.new(string_table_ptr)
+    group_names = Fiddle::Pointer.new(string_table["string"])[0, Fiddle::SIZEOF_VOIDP * string_table["size"]].unpack("Q*").collect { |ptr| Fiddle::Pointer.new(ptr).to_s }
+    TA_GroupTableFree(string_table_ptr)
+
+    group_names
+  end
+
+  def function_table(group)
+    string_table_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    ret_code = TA_FuncTableAlloc(group, string_table_ptr.ref)
+    check_ta_return_code(ret_code)
+
+    string_table = TA_StringTable.new(string_table_ptr)
+    func_names = Fiddle::Pointer.new(string_table["string"])[0, Fiddle::SIZEOF_VOIDP * string_table["size"]].unpack("Q*").collect { |ptr| Fiddle::Pointer.new(ptr).to_s }
+
+    TA_FuncTableFree(string_table)
+
+    func_names
+  end
+
+  def function_info(name)
+    handle_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    ret_code = TA_GetFuncHandle(name, handle_ptr.ref)
+    check_ta_return_code(ret_code)
+
+    info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    ret_code = TA_GetFuncInfo(handle_ptr, info_ptr.ref)
+    check_ta_return_code(ret_code)
+
+    TA_FuncInfo.new(info_ptr)
+  end
+
+  def each_function(&block)
+    callback = Fiddle::Closure::BlockCaller.new(
+      Fiddle::TYPE_VOID,
+      [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP],
+      Fiddle::Function::DEFAULT
+    ) do |func_info_ptr, _|
+      block.call TA_FuncInfo.new(func_info_ptr)
+    end
+
+    ret_code = TA_ForEachFunc(callback, nil)
+    check_ta_return_code(ret_code)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def print_function_info(func_info)
+    puts "Function Name: #{func_info["name"]}"
+    puts "Function Group: #{func_info["group"]}"
+    puts "Function Hint: #{func_info["hint"]}"
+    puts "Camel Case Name: #{func_info["camelCaseName"]}"
+    puts "Flags: #{func_info["flags"]}"
+    puts "Number of Inputs: #{func_info["nbInput"]}"
+    puts "Number of Optional Inputs: #{func_info["nbOptInput"]}"
+    puts "Number of Outputs: #{func_info["nbOutput"]}"
+    puts "Function Handle: #{func_info["handle"].to_i}"
+
+    puts "\nInput Parameter Info:"
+    func_info["nbInput"].times do |i|
+      param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      ret_code = TA_GetInputParameterInfo(func_info["handle"], i, param_info_ptr.ref)
+      check_ta_return_code(ret_code)
+      param_info = TA_InputParameterInfo.new(param_info_ptr)
+      puts "  Parameter #{i + 1}:"
+      puts "    Name: #{param_info["paramName"]}"
+      puts "    Type: #{param_info["type"]}"
+      puts "    Flags: #{extract_flags(param_info["flags"], :TA_InputFlags)}"
+    end
+
+    puts "\nOptional Input Parameter Info:"
+    func_info["nbOptInput"].times do |i|
+      param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      ret_code = TA_GetOptInputParameterInfo(func_info["handle"], i, param_info_ptr.ref)
+      check_ta_return_code(ret_code)
+      param_info = TA_OptInputParameterInfo.new(param_info_ptr)
+      puts "  Parameter #{i + 1}:"
+      puts "    Name: #{param_info["paramName"]}"
+      puts "    Type: #{param_info["type"]}"
+      puts "    Flags: #{extract_flags(param_info["flags"], :TA_OptInputFlags)}"
+      puts "    Display Name: #{param_info["displayName"]}"
+      puts "    Default Value: #{param_info["defaultValue"]}"
+      puts "    Hint: #{param_info["hint"]}"
+    end
+
+    puts "\nOutput Parameter Info:"
+    func_info["nbOutput"].times do |i|
+      param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      ret_code = TA_GetOutputParameterInfo(func_info["handle"], i, param_info_ptr.ref)
+      check_ta_return_code(ret_code)
+      param_info = TA_OutputParameterInfo.new(param_info_ptr)
+      puts "  Parameter #{i + 1}:"
+      puts "    Name: #{param_info["paramName"]}"
+      puts "    Type: #{param_info["type"]}"
+      puts "    Flags: #{extract_flags(param_info["flags"], :TA_OutputFlags)}"
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  # rubocop:disable Metrics/MethodLength
+  def call_func(func_name, args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    input_arrays = args
+
+    validate_inputs!(input_arrays)
+
+    handle_ptr = get_function_handle(func_name)
+    params_ptr = create_parameter_holder(handle_ptr)
+
+    begin
+      setup_input_parameters(params_ptr, input_arrays, func_name)
+      setup_optional_parameters(params_ptr, options, func_name)
+      _lookback = calculate_lookback(params_ptr)
+      calculate_results(params_ptr, input_arrays.first.length, func_name)
+    ensure
+      TA_ParamHolderFree(params_ptr)
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def calculate_lookback(params_ptr)
+    lookback_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+    ret_code = TA_GetLookback(params_ptr, lookback_ptr)
+    check_ta_return_code(ret_code)
+    lookback_ptr[0, Fiddle::SIZEOF_INT].unpack1("l")
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
+  def validate_inputs!(arrays)
+    raise TALibError, "Input arrays cannot be empty" if arrays.empty?
+
+    arrays.each do |arr|
+      raise TALibError, "Input must be arrays" unless arr.is_a?(Array)
+    end
+
+    sizes = arrays.map(&:length)
+    raise TALibError, "Input arrays cannot be empty" if sizes.any?(&:zero?)
+
+    arrays.each do |arr|
+      raise TALibError, "Input arrays must contain only numbers" unless arr.flatten.all? { |x| x.is_a?(Numeric) }
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
+
+  def get_function_handle(func_name)
+    handle_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    ret_code = TA_GetFuncHandle(func_name, handle_ptr.ref)
+    check_ta_return_code(ret_code)
+    handle_ptr
+  end
+
+  def create_parameter_holder(handle_ptr)
+    params_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    ret_code = TA_ParamHolderAlloc(handle_ptr, params_ptr.ref)
+    check_ta_return_code(ret_code)
+    params_ptr
+  end
+
+  def setup_input_parameters(params_ptr, input_arrays, func_name)
+    func_info = function_info_map[func_name]
+    input_arrays.each_with_index do |array, index|
+      input_info = func_info[:inputs][index]
+      ret_code = set_input_parameter(params_ptr, index, array, input_info)
+      check_ta_return_code(ret_code)
+    end
+  end
+
+  def set_input_parameter(params_ptr, index, array, input_info)
+    case input_info["type"]
+    when TA_PARAM_TYPE[:TA_Input_Real]
+      input_ptr = prepare_double_array(array)
+      TA_SetInputParamRealPtr(params_ptr, index, input_ptr)
+    when TA_PARAM_TYPE[:TA_Input_Integer]
+      input_ptr = prepare_integer_array(array)
+      TA_SetInputParamIntegerPtr(params_ptr, index, input_ptr)
+    when TA_PARAM_TYPE[:TA_Input_Price]
+      setup_price_inputs(params_ptr, index, array, input_info["flags"])
+    end
+  end
+
+  def prepare_double_array(array)
+    array_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE * array.length)
+    array.each_with_index do |value, i|
+      array_ptr[i * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE] = [value.to_f].pack("d")
+    end
+    array_ptr
+  end
+
+  def prepare_integer_array(array)
+    array_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT * array.length)
+    array.each_with_index do |value, i|
+      array_ptr[i * Fiddle::SIZEOF_INT, Fiddle::SIZEOF_INT] = [value.to_i].pack("l")
+    end
+    array_ptr
+  end
+
+  def setup_optional_parameters(params_ptr, options, func_name)
+    func_info = function_info_map[func_name]
+    func_info[:opt_inputs]&.each_with_index do |opt_input, index|
+      param_name = normalize_parameter_name(opt_input["paramName"].to_s)
+      set_optional_parameter(params_ptr, index, options[param_name.to_sym], opt_input["type"]) if options.key?(param_name.to_sym)
+    end
+  end
+
+  def set_optional_parameter(params_ptr, index, value, type)
+    case type
+    when TA_PARAM_TYPE[:TA_OptInput_RealRange], TA_PARAM_TYPE[:TA_OptInput_RealList]
+      ret_code = TA_SetOptInputParamReal(params_ptr, index, value)
+    when TA_PARAM_TYPE[:TA_OptInput_IntegerRange], TA_PARAM_TYPE[:TA_OptInput_IntegerList]
+      ret_code = TA_SetOptInputParamInteger(params_ptr, index, value)
+    end
+    check_ta_return_code(ret_code)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def calculate_results(params_ptr, input_size, func_name)
+    out_begin = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+    out_size = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+    output_arrays = setup_output_buffers(params_ptr, input_size, func_name)
+
+    begin
+      ret_code = TA_CallFunc(params_ptr, 0, input_size - 1, out_begin, out_size)
+      check_ta_return_code(ret_code)
+
+      actual_size = out_size[0, Fiddle::SIZEOF_INT].unpack1("l")
+      format_output_results(output_arrays, actual_size, func_name)
+    ensure
+      out_begin.free
+      out_size.free
+      output_arrays.each(&:free)
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def setup_output_buffers(params_ptr, size, func_name)
+    func_info = function_info_map[func_name]
+    output_ptrs = []
+
+    func_info[:outputs].each_with_index do |output, index|
+      ptr = case output["type"]
+            when TA_PARAM_TYPE[:TA_Output_Real]
+              Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE * size)
+            when TA_PARAM_TYPE[:TA_Output_Integer]
+              Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT * size)
+            end
+
+      output_ptrs << ptr
+
+      ret_code =  case output["type"]
+                  when TA_PARAM_TYPE[:TA_Output_Real]
+                    TA_SetOutputParamRealPtr(params_ptr, index, ptr)
+                  when TA_PARAM_TYPE[:TA_Output_Integer]
+                    TA_SetOutputParamIntegerPtr(params_ptr, index, ptr)
+                  end
+
+      check_ta_return_code(ret_code)
+    end
+
+    output_ptrs
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def format_output_results(output_ptrs, size, func_name)
+    func_info = function_info_map[func_name]
+    results = output_ptrs.zip(func_info[:outputs]).map do |ptr, output|
+      case output["type"]
+      when TA_PARAM_TYPE[:TA_Output_Real]
+        ptr[0, Fiddle::SIZEOF_DOUBLE * size].unpack("d#{size}")
+      when TA_PARAM_TYPE[:TA_Output_Integer]
+        ptr[0, Fiddle::SIZEOF_INT * size].unpack("l#{size}")
+      end
+    end
+
+    return results.first if results.length == 1
+
+    output_names = func_info[:outputs].map do |output|
+      normalize_parameter_name(output["paramName"].to_s).to_sym
+    end
+    output_names.zip(results).to_h
+  end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
+
+  def function_description_xml
+    TA_FunctionDescriptionXML().to_s
+  end
+
+  def function_info_map
+    @function_info_map ||= build_function_info_map
+  end
+
+  def build_function_info_map
+    info_map = {}
+    each_function do |func_info|
+      info_map[func_info["name"].to_s] = {
+        info: func_info,
+        inputs: collect_input_info(func_info),
+        outputs: collect_output_info(func_info),
+        opt_inputs: collect_opt_input_info(func_info)
+      }
+    end
+    info_map
+  end
+
+  def collect_input_info(func_info)
+    func_info["nbInput"].times.map do |i|
+      param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      TA_GetInputParameterInfo(func_info["handle"], i, param_info_ptr.ref)
+      TA_InputParameterInfo.new(param_info_ptr)
+    end
+  end
+
+  def collect_opt_input_info(func_info)
+    func_info["nbOptInput"].times.map do |i|
+      param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      TA_GetOptInputParameterInfo(func_info["handle"], i, param_info_ptr.ref)
+      TA_OptInputParameterInfo.new(param_info_ptr)
+    end
+  end
+
+  def collect_output_info(func_info)
+    func_info["nbOutput"].times.map do |i|
+      param_info_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      TA_GetOutputParameterInfo(func_info["handle"], i, param_info_ptr.ref)
+      TA_OutputParameterInfo.new(param_info_ptr)
+    end
+  end
+
+  def generate_ta_functions
+    each_function do |func_info|
+      define_ta_function(func_info["name"].to_s.downcase, func_info["name"].to_s)
+    end
+  end
+
+  def normalize_parameter_name(name)
+    name.sub(/^(optIn|outReal|outInteger|out)/, "")
+        .gsub(/::/, "/")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def check_ta_return_code(code)
+    return if code == TA_SUCCESS
+
+    error_message = case code
+                    when TA_LIB_NOT_INITIALIZE
+                      "TA-Lib not initialized, please call TA_Initialize first"
+                    when TA_BAD_PARAM
+                      "Bad parameter, please check input parameters"
+                    when TA_ALLOC_ERR
+                      "Memory allocation error, possibly insufficient memory"
+                    when TA_GROUP_NOT_FOUND
+                      "Function group not found"
+                    when TA_FUNC_NOT_FOUND
+                      "Function not found"
+                    when TA_INVALID_HANDLE
+                      "Invalid handle"
+                    when TA_INVALID_PARAM_HOLDER
+                      "Invalid parameter holder"
+                    when TA_INVALID_PARAM_HOLDER_TYPE
+                      "Invalid parameter holder type"
+                    when TA_INVALID_PARAM_FUNCTION
+                      "Invalid parameter function"
+                    when TA_INPUT_NOT_ALL_INITIALIZE
+                      "Input parameters not fully initialized"
+                    when TA_OUTPUT_NOT_ALL_INITIALIZE
+                      "Output parameters not fully initialized"
+                    when TA_OUT_OF_RANGE_START_INDEX
+                      "Start index out of range"
+                    when TA_OUT_OF_RANGE_END_INDEX
+                      "End index out of range"
+                    when TA_INVALID_LIST_TYPE
+                      "Invalid list type"
+                    when TA_BAD_OBJECT
+                      "Invalid object"
+                    when TA_NOT_SUPPORTED
+                      "Operation not supported"
+                    when TA_INTERNAL_ERROR
+                      "TA-Lib internal error"
+                    when TA_UNKNOWN_ERR
+                      "Unknown error"
+                    else
+                      "Undefined TA-Lib error (Error code: #{code})"
+                    end
+
+    raise TALibError, error_message
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  def initialize_ta_lib
+    return if @initialized
+
+    ret_code = TA_Initialize()
+    check_ta_return_code(ret_code)
+    at_exit { TA_Shutdown() }
+    @initialized = true
+  end
+
+  def define_ta_function(method_name, func_name)
+    define_singleton_method(method_name) do |*args|
+      call_func(func_name, args)
+    end
+  end
+
+  def setup_price_inputs(params_ptr, index, price_data, flags)
+    required_flags = extract_flags(flags, :TA_InputFlags)
+    data_pointers = Array.new(6) { nil }
+    TA_FLAGS[:TA_InputFlags].keys[0..5].each_with_index do |flag, i|
+      data_pointers[i] = if required_flags.include?(flag)
+                           prepare_double_array(price_data[required_flags.index(flag)])
+                         else
+                           Fiddle::Pointer.malloc(0)
+                         end
+    end
+
+    TA_SetInputParamPricePtr(params_ptr, index, *data_pointers)
+  end
+
+  initialize_ta_lib
+  generate_ta_functions
+end

data/ta_lib_ffi.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/ta_lib"
+
+Gem::Specification.new do |spec|
+  spec.name = "ta_lib_ffi"
+  spec.version = TALib::VERSION
+  spec.authors = ["Victor Yang"]
+  spec.email = ["victor@rt4u.bid"]
+  spec.summary = "Ruby FFI bindings for TA-Lib (Technical Analysis Library)"
+  spec.description = "A Ruby wrapper for TA-Lib using FFI, providing technical analysis functions for financial market data"
+  spec.homepage = "https://github.com/Youngv/ta_lib_ffi"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Youngv/ta_lib_ffi"
+  spec.metadata["changelog_uri"] = "https://github.com/Youngv/ta_lib_ffi/blob/main/CHANGELOG.md"
+  spec.files = Dir[
+    "lib/**/*",
+    "LICENSE.txt",
+    "README.md",
+    "CHANGELOG.md",
+    "Gemfile",
+    "Rakefile",
+    "ta_lib_ffi.gemspec",
+  ]
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "fiddle", "~> 1.1"
+  spec.add_development_dependency "rake", "~> 13.2"
+  spec.add_development_dependency "rspec", "~> 3.13"
+  spec.add_development_dependency "rubocop-rspec", "~> 3.3"
+  spec.add_development_dependency "ruby-lsp-rspec", "~> 0.1.20"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: ta_lib_ffi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Victor Yang
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.20
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.20
+description: A Ruby wrapper for TA-Lib using FFI, providing technical analysis functions
+  for financial market data
+email:
+- victor@rt4u.bid
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ta_lib.rb
+- ta_lib_ffi.gemspec
+homepage: https://github.com/Youngv/ta_lib_ffi
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Youngv/ta_lib_ffi
+  source_code_uri: https://github.com/Youngv/ta_lib_ffi
+  changelog_uri: https://github.com/Youngv/ta_lib_ffi/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Ruby FFI bindings for TA-Lib (Technical Analysis Library)
+test_files: []