Migrate Ruby bindings from helix to rutie

.github/workflows/ruby_build.yml

@@ -17,15 +17,15 @@ jobs:
     - name: Cache Rust build
       uses: actions/[email protected]
       with:
-        path: target/debug/build
-        key: ruby-${{ runner.OS }}-target-build-${{ hashFiles('**/Cargo.lock') }}
+        path: target/release/build
+        key: ruby-${{ runner.OS }}-target-release-${{ hashFiles('**/Cargo.lock') }}
         restore-keys: |
           ruby-${{ runner.OS }}-target-build-
     - name: Cache Rust incremental build
       uses: actions/[email protected]
       with:
-        path: target/debug/incremental
-        key: ruby-${{ runner.OS }}-target-incremental-${{ hashFiles('**/Cargo.lock') }}
+        path: target/release/incremental
+        key: ruby-${{ runner.OS }}-target-release-incremental-${{ hashFiles('**/Cargo.lock') }}
         restore-keys: |
           ruby-${{ runner.OS }}-target-incremental-
     - name: Install minimal stable with clippy and rustfmt
@@ -34,6 +34,8 @@ jobs:
         profile: default
         toolchain: stable
         override: true
+    - name: Build Release for Ruby
+      run: cargo build --release
     - name: 'Set up Ruby'
       uses: actions/setup-ruby@v1
     - name: 'Install Ruby Dependencies'

ruby/Cargo.toml

@@ -4,11 +4,11 @@ version = "0.1.0"
 authors = ["R Tyler Croy <[email protected]>"]
 
 [lib]
-
 crate-type = ["cdylib"]
 
 [dependencies]
-helix = "*"
+lazy_static = "1"
+rutie = "0.8.2"
 tokio = { version = "1", features = ["rt-multi-thread"] }
 
 [dependencies.deltalake]

ruby/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
-gem 'helix_runtime'
 gem 'colorize'
+gem 'rutie', '~> 0.0.3'
 
 group :development do
   gem 'rake', '~> 12.0'

ruby/Rakefile

@@ -1,17 +1,13 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
-require 'helix_runtime/build_task'
 require 'rspec/core/rake_task'
 
 # For Windows
 $stdout.sync = true
 
-HelixRuntime::BuildTask.new do |t|
-  t.build_root = File.expand_path("../", __dir__)
-end
-
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
 end
 
-task :spec => :build
-task :default => :spec
+task default: :spec

ruby/lib/deltalake.rb

@@ -1,7 +1,11 @@
-require 'helix_runtime'
-require 'deltalake-ruby/native'
+# frozen_string_literal: true
+
+require 'deltalake/version'
+require 'rutie'
 
 module Deltalake
+  Rutie.new(:deltalake_ruby, lib_path: '../../target/release').init 'Init_table', __dir__
+
   def self.open_table(table_path)
     Table.new(table_path)
   end

ruby/lib/deltalake/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Deltalake
+  VERSION = '0.1.0'
+end

ruby/spec/deltalake_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'deltalake'
 
@@ -17,6 +19,16 @@
 
       it { should be_instance_of Array }
       its(:size) { should eq(5) }
+
+      it {
+        should contain_exactly(
+          'part-00000-2befed33-c358-4768-a43c-3eda0d2a499d-c000.snappy.parquet',
+          'part-00000-c1777d7d-89d9-4790-b38a-6ee7e24456b1-c000.snappy.parquet',
+          'part-00007-3a0e4727-de0d-41b6-81ef-5223cf40f025-c000.snappy.parquet',
+          'part-00001-7891c33d-cedc-47c3-88a6-abcfb049d3b4-c000.snappy.parquet',
+          'part-00004-315835fe-fb44-4562-98f6-5e6cfa3ae45d-c000.snappy.parquet'
+        )
+      }
     end
   end
 end

ruby/src/lib.rs

@@ -1,43 +1,91 @@
 #![recursion_limit = "1024"]
 
-#[macro_use]
-extern crate helix;
 extern crate deltalake;
 
+#[macro_use]
+extern crate lazy_static;
+
+#[macro_use]
+extern crate rutie;
+
 use deltalake::DeltaTable;
+use rutie::{AnyObject, Array, Class, Integer, Object, RString};
 use std::sync::Arc;
 
-ruby! {
-    class Table {
-        struct {
-            table_path: String,
-            actual: Arc<DeltaTable>,
-        }
+pub struct TableData {
+    table_path: String,
+    actual: Arc<DeltaTable>,
+}
 
-        def initialize(helix, table_path: String) {
-            println!("initializing with {}", table_path);
+impl TableData {
+    fn new(table_path: String) -> Self {
+        println!("initializing with {}", table_path);
 
-            let rt = tokio::runtime::Runtime::new().unwrap();
-            let table = rt.block_on(deltalake::open_table(&table_path)).unwrap();
-            let actual = Arc::new(table);
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let table = rt.block_on(deltalake::open_table(&table_path)).unwrap();
+        let actual = Arc::new(table);
 
-            Table {
-                helix,
-                table_path,
-                actual,
-            }
-        }
+        Self { table_path, actual }
+    }
 
-        def table_path(&self) -> String {
-            self.table_path.clone()
-        }
+    fn table_path(&self) -> &str {
+        &self.table_path
+    }
 
-        def version(&self) -> i64 {
-            self.actual.version
-        }
+    fn version(&self) -> i64 {
+        self.actual.version
+    }
 
-        def files(&self) -> Vec<String> {
-            self.actual.get_files().to_vec()
+    fn files(&self) -> &[String] {
+        self.actual.get_files().as_slice()
+    }
+}
+
+wrappable_struct!(TableData, TableDataWrapper, TABLE_DATA_WRAPPER);
+
+class!(Table);
+
+methods!(
+    Table,
+    rtself,
+    fn ruby_table_new(table_path: RString) -> AnyObject {
+        let table_data = TableData::new(table_path.unwrap().to_string());
+
+        Class::from_existing("Table").wrap_data(table_data, &*TABLE_DATA_WRAPPER)
+    },
+    fn ruby_table_path() -> RString {
+        let table_path = rtself.get_data(&*TABLE_DATA_WRAPPER).table_path();
+
+        RString::new_utf8(table_path)
+    },
+    fn ruby_version() -> Integer {
+        let version = rtself.get_data(&*TABLE_DATA_WRAPPER).version();
+
+        Integer::new(version)
+    },
+    fn ruby_files() -> Array {
+        let files = rtself.get_data(&*TABLE_DATA_WRAPPER).files();
+
+        let mut array = Array::with_capacity(files.len());
+
+        for file in files {
+            array.push(RString::new_utf8(file));
         }
+
+        array
     }
+);
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_table() {
+    let data_class = Class::from_existing("Object");
+
+    Class::new("Table", Some(&data_class)).define(|klass| {
+        klass.def_self("new", ruby_table_new);
+
+        klass.def("table_path", ruby_table_path);
+        klass.def("version", ruby_version);
+        klass.def("files", ruby_files);
+    });
 }