refactor: modularize Rust codebase and enhance CI/CD pipeline (#45)

- Reorganize Rust modules: extract dispersion.rs and mathematics.rs from lib.rs
- Implement thiserror for improved error handling and Magnus error conversion
- Add rb-sys-env build dependency and enable rb-sys feature for better FFI
- Introduce continuous delivery workflow with gem artifact building
- Update branch protection workflow and rename from main.yml
- Switch default Rake task from compile to compile:dev for development
- Add .rules file to gitignore and update test coverage

Author: corybuecker

.DS_Store

@@ -1,11 +1,12 @@
-name: Test suite
-
+name: branch-protection
 on:
-  - push
-
+  pull_request:
+    branches:
+      - main
+permissions:
+  contents: read
 jobs:
-  run-tests:
-    name: Run tests
+  test:
     strategy:
       matrix:
         os:
@@ -21,6 +22,6 @@ jobs:
       - uses: ruby/setup-ruby@a9bfc2ecf3dd40734a9418f89a7e9d484c32b990
         with:
           ruby-version: ${{ matrix.ruby }}
-      - run: gem install bundler --version 2.7.0 --no-document
+      - run: gem install bundler --no-document
       - run: bundle
       - run: rake

.github/.DS_Store

@@ -0,0 +1,34 @@
+name: continuous-delivery
+
+permissions:
+  packages: write
+
+on:
+  push:
+    branches:
+      - main
+concurrency:
+  group: continuous-delivery
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Run tests
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - uses: ruby/setup-ruby@a9bfc2ecf3dd40734a9418f89a7e9d484c32b990
+        with:
+          ruby-version: 3.4.4
+      - run: gem install bundler --no-document
+      - run: bundle
+      - run: rake native gem
+      - uses: actions/upload-artifact@v4
+        with:
+          name: gem-${{ matrix.os }}
+          path: pkg/*-${{ matrix.os }}.gem

.github/workflows/main.yml .github/workflows/branch-protection.yaml.github/workflows/main.yml renamed to .github/workflows/branch-protection.yaml

@@ -59,3 +59,4 @@ build-iPhoneSimulator/
 
 /ext/ruby_native_statistics/target
 /target
+/.rules

.github/workflows/continuous-delivery.yaml

@@ -15,4 +15,4 @@ Rake::TestTask.new benchmark: [:clean, :clobber, 'compile:release'] do |t|
   t.test_files = ['test/**/*_benchmark.rb']
 end
 
-task :default => [:compile, :test]
+task :default => ['compile:dev', :test]

.gitignore

@@ -7,4 +7,8 @@ edition = "2024"
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.7.1" }
+magnus = { version = "0.7.1", features = ["rb-sys"] }
+thiserror = "2.0.12"
+
+[build-dependencies]
+rb-sys-env = "0.1"

Cargo.lock

@@ -0,0 +1,128 @@
+use magnus::{Error, RArray, Ruby};
+
+#[derive(thiserror::Error, Debug)]
+pub enum DispersionError {
+    #[error("Array must have at least one element")]
+    EmptyArray,
+
+    #[error("Input is out of range")]
+    RangeError,
+
+    #[error("Magnus error")]
+    MagnusError(magnus::Error),
+}
+
+impl magnus::error::IntoError for DispersionError {
+    fn into_error(self, ruby: &Ruby) -> Error {
+        match self {
+            DispersionError::EmptyArray => {
+                Error::new(ruby.exception_range_error(), self.to_string())
+            }
+            DispersionError::RangeError => {
+                Error::new(ruby.exception_range_error(), self.to_string())
+            }
+            DispersionError::MagnusError(err) => err,
+        }
+    }
+}
+
+fn calculate_mean(array: &[f64]) -> f64 {
+    let length = array.len() as f64;
+    let sum = array.iter().sum::<f64>();
+    sum / length
+}
+
+fn calculate_variance(array: &[f64], population: bool) -> f64 {
+    let length = array.len() as f64;
+    let distance_from_mean = distance_from_mean(array);
+    let divisor = if population { length } else { length - 1.0 };
+    distance_from_mean / divisor
+}
+
+fn calculate_stdev(array: &[f64], population: bool) -> f64 {
+    calculate_variance(array, population).sqrt()
+}
+
+fn distance_from_mean(array: &[f64]) -> f64 {
+    let mean = calculate_mean(array);
+
+    array.iter().fold(0.0, |acc, x| acc + (x - mean).powi(2))
+}
+
+pub fn var(rb_self: RArray) -> Result<f64, DispersionError> {
+    let array = rb_self
+        .to_vec::<f64>()
+        .map_err(|e| DispersionError::MagnusError(e))?;
+
+    if array.is_empty() {
+        return Err(DispersionError::EmptyArray);
+    }
+
+    Ok(calculate_variance(&array, false))
+}
+
+pub fn stdev(rb_self: RArray) -> Result<f64, DispersionError> {
+    let array = rb_self
+        .to_vec::<f64>()
+        .map_err(|e| DispersionError::MagnusError(e))?;
+
+    if array.is_empty() {
+        return Err(DispersionError::EmptyArray);
+    }
+
+    Ok(calculate_stdev(&array, false))
+}
+
+pub fn varp(rb_self: RArray) -> Result<f64, DispersionError> {
+    let array = rb_self
+        .to_vec::<f64>()
+        .map_err(|e| DispersionError::MagnusError(e))?;
+
+    if array.is_empty() {
+        return Err(DispersionError::EmptyArray);
+    }
+
+    Ok(calculate_variance(&array, true))
+}
+
+pub fn stdevp(rb_self: RArray) -> Result<f64, DispersionError> {
+    let array = rb_self
+        .to_vec::<f64>()
+        .map_err(|e| DispersionError::MagnusError(e))?;
+
+    if array.is_empty() {
+        return Err(DispersionError::EmptyArray);
+    }
+
+    Ok(calculate_stdev(&array, true))
+}
+
+fn calculate_percentile(array: &mut [f64], percentile: f64) -> Result<f64, DispersionError> {
+    let length = array.len() as f64;
+
+    array.sort_by(|a, b| a.total_cmp(b));
+
+    let h = (length - 1.0) * percentile + 1.0;
+    if h.trunc() == h {
+        Ok(array[(h as usize) - 1])
+    } else {
+        let h_floor = h.trunc() as usize;
+
+        Ok((h - h_floor as f64) * (array[h_floor] - array[h_floor - 1]) + array[h_floor - 1])
+    }
+}
+pub fn percentile(rb_self: RArray, percentile: f64) -> Result<f64, DispersionError> {
+    let mut array = rb_self
+        .to_vec::<f64>()
+        .map_err(|e| DispersionError::MagnusError(e))?;
+
+    if array.is_empty() {
+        return Err(DispersionError::EmptyArray);
+    }
+
+    if !(0.0..=1.0).contains(&percentile) {
+        return Err(DispersionError::RangeError);
+    }
+
+    calculate_percentile(&mut array, percentile)
+}