cruise 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6c28ff18160ebdea05cff957fa6d2c3933a74776541a241b194b36c4ec382d1
-  data.tar.gz: 0e963d79323ee6ea95684080d0194fad512009f3429664ffa2c6d32aa3a0d0ee
+  metadata.gz: 987534c3a5048aa06fd63879c5788c25e39cee765722c80d3c64da33472d06f8
+  data.tar.gz: 32f9ec736fab2350f7d299f7eeb09a78f4826b8d377c1ae12fe8fb19509efbcd
 SHA512:
-  metadata.gz: 9d46bd683e1ddff54bce8693b613c2d589f968bc6b0d1d87359d1eb090a5d4f05109abfb9d8a8eb9c11cdaf4d1bfe7abd5fe73801a3b68c07ee6881f1a983e7b
-  data.tar.gz: f135cf89f25790b30c507949bc2d9dfb27d6dcbe12eeefc710be9165a5601e258abd33771346f66f7d69b28b9d2ec689214488ea46d0d4aec639ee3ed5489e69
+  metadata.gz: fce59791b4839f1090c02e02ae88d6874ecce6e8187107ce1c9538cabff63efee8be63992b7de581196b25834894cf76a46d1766cdf4ed826ef50e9caa538c19
+  data.tar.gz: 2c5d792a2ac97d23edae8c3ac287b07f8faa7187f5fd13d1fb5d0578d3bdedf00af95591445c3283071e27a8bebc1a44ad30c195276a5f35f9d0410153a9c6c9

data/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["ext/cruise"]
+resolver = "2"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Marco Roth
+
+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/Rakefile

@@ -1,12 +1,82 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "minitest/test_task"
+require "rake/testtask"
 
-Minitest::TestTask.create
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
 
-require "rubocop/rake_task"
+begin
+  require "rake/extensiontask"
+  require "rb_sys"
+  require "rb_sys/extensiontask"
 
-RuboCop::RakeTask.new
+  PLATFORMS = [
+    "aarch64-linux-gnu",
+    "aarch64-linux-musl",
+    "arm-linux-gnu",
+    "arm64-darwin",
+    "x86_64-darwin",
+    "x86_64-linux-gnu",
+    "x86_64-linux-musl"
+  ].freeze
 
-task default: %i[test rubocop]
+  RB_SYS_PLATFORM_MAP = {
+    "aarch64-linux-gnu" => "aarch64-linux",
+    "aarch64-linux-musl" => "aarch64-linux-musl",
+    "arm-linux-gnu" => "arm-linux",
+    "arm64-darwin" => "arm64-darwin",
+    "x86_64-darwin" => "x86_64-darwin",
+    "x86_64-linux-gnu" => "x86_64-linux",
+    "x86_64-linux-musl" => "x86_64-linux-musl"
+  }.freeze
+
+  RbSys::ExtensionTask.new("cruise", Gem::Specification.load("cruise.gemspec")) do |ext|
+    ext.lib_dir = "lib/cruise"
+    ext.cross_compile = true
+    ext.cross_platform = PLATFORMS
+  end
+
+  namespace "gem" do
+    task "prepare" do
+      require "rake_compiler_dock"
+
+      sh "bundle config set cache_all true"
+
+      gemspec_path = File.expand_path("./cruise.gemspec", __dir__)
+      spec = eval(File.read(gemspec_path), binding, gemspec_path)
+
+      RakeCompilerDock.set_ruby_cc_version(spec.required_ruby_version.as_list)
+    rescue LoadError
+      abort "rake_compiler_dock is required for this task"
+    end
+
+    PLATFORMS.each do |platform|
+      desc "Build all native binary gems in parallel"
+      multitask "native" => platform
+
+      desc "Build the native gem for #{platform}"
+      task platform => "prepare" do
+        rb_sys_platform = RB_SYS_PLATFORM_MAP.fetch(platform)
+
+        RakeCompilerDock.sh(
+          "bundle install && bundle exec rake native:#{platform} gem RUBY_CC_VERSION='#{ENV.fetch("RUBY_CC_VERSION", nil)}'",
+          platform: platform,
+          image: "rbsys/#{rb_sys_platform}:#{RbSys::VERSION}"
+        )
+      end
+    end
+  end
+rescue LoadError => e
+  warn "WARNING: Failed to load extension tasks: #{e.message}"
+
+  desc "Compile task not available (rake-compiler not installed)"
+  task :compile do
+    abort "rake-compiler is required: #{e.message}\n\nRun: bundle install"
+  end
+end
+
+task default: [:compile, :test]

data/cruise.gemspec

@@ -13,20 +13,26 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/marcoroth/cruise"
   spec.license = "MIT"
 
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 3.2.0"
   spec.require_paths = ["lib"]
 
   spec.files = Dir[
     "cruise.gemspec",
     "LICENSE.txt",
+    "Cargo.toml",
     "Rakefile",
-    "lib/**/*.rb"
+    "lib/**/*.rb",
+    "ext/**/*.{rs,toml,rb,lock}"
   ]
 
+  spec.extensions = ["ext/cruise/extconf.rb"]
+
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+
+  spec.add_dependency "rb_sys"
 end

data/ext/cruise/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cruise"
+version = "0.1.0"
+edition = "2024"
+license = "MIT"
+publish = false
+
+[dependencies]
+magnus = { version = "0.8", features = ["rb-sys"] }
+rb-sys = { version = "0.9" }
+notify = { version = "7", features = ["macos_fsevent"] }
+notify-debouncer-full = "0.4"
+globset = "0.4"
+
+[lib]
+crate-type = ["cdylib"]

data/ext/cruise/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("cruise/cruise")

data/ext/cruise/src/lib.rs

@@ -0,0 +1,213 @@
+use std::path::PathBuf;
+
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use magnus::{method, prelude::*, value::Lazy, Error, IntoValue, RClass, RModule, Ruby, Value};
+
+use notify::event::{CreateKind, ModifyKind, RemoveKind};
+use notify::{EventKind, RecursiveMode};
+use notify_debouncer_full::{new_debouncer, DebounceEventResult};
+
+static MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Cruise").expect("failed to define Cruise module"));
+
+static EVENT_CLASS: Lazy<RClass> = Lazy::new(|ruby| {
+  let module = ruby.get_inner(&MODULE);
+  let class = module.define_class("Event", ruby.class_object()).expect("failed to define Cruise::Event class");
+
+  class
+    .define_method("path", method!(CruiseEvent::path, 0))
+    .expect("failed to define path method");
+
+  class
+    .define_method("kind", method!(CruiseEvent::kind, 0))
+    .expect("failed to define kind method");
+
+  class
+    .define_method("inspect", method!(CruiseEvent::inspect, 0))
+    .expect("failed to define inspect method");
+
+  class
+    .define_method("to_s", method!(CruiseEvent::to_s, 0))
+    .expect("failed to define to_s method");
+
+  class
+});
+
+#[magnus::wrap(class = "Cruise::Event", free_immediately)]
+struct CruiseEvent {
+  path: String,
+  kind: String,
+}
+
+impl CruiseEvent {
+  fn path(&self) -> &str {
+    &self.path
+  }
+
+  fn kind(&self) -> &str {
+    &self.kind
+  }
+
+  fn inspect(&self) -> String {
+    format!("#<Cruise::Event kind={:?} path={:?}>", self.kind, self.path)
+  }
+
+  fn to_s(&self) -> String {
+    format!("{}: {}", self.kind, self.path)
+  }
+}
+
+fn event_kind_to_string(kind: &EventKind) -> &'static str {
+  match kind {
+    EventKind::Create(CreateKind::File) => "created",
+    EventKind::Create(CreateKind::Folder) => "created",
+    EventKind::Create(_) => "created",
+    EventKind::Modify(ModifyKind::Data(_)) => "modified",
+    EventKind::Modify(ModifyKind::Name(_)) => "renamed",
+    EventKind::Modify(_) => "modified",
+    EventKind::Remove(RemoveKind::File) => "removed",
+    EventKind::Remove(RemoveKind::Folder) => "removed",
+    EventKind::Remove(_) => "removed",
+    EventKind::Access(_) => "accessed",
+    EventKind::Any | EventKind::Other => "changed",
+  }
+}
+
+fn build_glob_set(patterns: Vec<String>) -> Result<Option<GlobSet>, Error> {
+  if patterns.is_empty() {
+    return Ok(None);
+  }
+
+  let mut builder = GlobSetBuilder::new();
+
+  for pattern in &patterns {
+    let glob = Glob::new(pattern).map_err(|error| {
+      Error::new(
+        magnus::Ruby::get().unwrap().exception_arg_error(),
+        format!("Invalid glob pattern '{}': {}", pattern, error),
+      )
+    })?;
+    builder.add(glob);
+  }
+
+  let set = builder.build().map_err(|error| {
+    Error::new(
+      magnus::Ruby::get().unwrap().exception_runtime_error(),
+      format!("Failed to build glob set: {}", error),
+    )
+  })?;
+
+  Ok(Some(set))
+}
+
+enum WaitResult {
+  Event(notify::Event),
+  Timeout,
+  Disconnected,
+}
+
+unsafe extern "C" fn wait_for_event(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
+  let receiver = unsafe { &*(data as *const std::sync::mpsc::Receiver<notify::Event>) };
+
+  let result = match receiver.recv_timeout(std::time::Duration::from_millis(200)) {
+    Ok(event) => Box::new(WaitResult::Event(event)),
+    Err(std::sync::mpsc::RecvTimeoutError::Timeout) => Box::new(WaitResult::Timeout),
+    Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => Box::new(WaitResult::Disconnected),
+  };
+
+  Box::into_raw(result) as *mut std::ffi::c_void
+}
+
+unsafe extern "C" fn unblock_wait(_data: *mut std::ffi::c_void) {}
+
+fn watch(
+  ruby: &Ruby,
+  paths: Vec<String>,
+  callback: magnus::block::Proc,
+  debounce: f64,
+  glob_patterns: Vec<String>,
+  only_kinds: Vec<String>,
+) -> Result<magnus::Value, Error> {
+  let debounce_duration = std::time::Duration::from_secs_f64(debounce);
+  let glob_set = build_glob_set(glob_patterns)?;
+  let filter_kinds = if only_kinds.is_empty() { None } else { Some(only_kinds) };
+
+  let (sender, receiver) = std::sync::mpsc::channel::<notify::Event>();
+
+  let mut debouncer = new_debouncer(debounce_duration, None, move |result: DebounceEventResult| {
+    if let Ok(events) = result {
+      for debounced_event in events {
+        let _ = sender.send(debounced_event.event);
+      }
+    }
+  })
+  .map_err(|error| Error::new(ruby.exception_runtime_error(), format!("Failed to create watcher: {error}")))?;
+
+  for path in &paths {
+    let watch_path = PathBuf::from(path);
+
+    if !watch_path.exists() {
+      return Err(Error::new(ruby.exception_arg_error(), format!("Path does not exist: {}", watch_path.display())));
+    }
+
+    debouncer
+      .watch(&watch_path, RecursiveMode::Recursive)
+      .map_err(|error| Error::new(ruby.exception_runtime_error(), format!("Failed to watch path: {error}")))?;
+  }
+
+  loop {
+    let result = unsafe {
+      rb_sys::rb_thread_call_without_gvl(
+        Some(wait_for_event),
+        &receiver as *const _ as *mut std::ffi::c_void,
+        Some(unblock_wait),
+        std::ptr::null_mut(),
+      )
+    };
+
+    let wait_result = unsafe { *Box::from_raw(result as *mut WaitResult) };
+
+    match &wait_result {
+      WaitResult::Event(event) => {
+        let kind_string = event_kind_to_string(&event.kind);
+
+        if let Some(ref allowed) = filter_kinds {
+          if !allowed.iter().any(|kind| kind == kind_string) {
+            continue;
+          }
+        }
+
+        for path in &event.paths {
+          if let Some(ref globs) = glob_set {
+            if !globs.is_match(path) {
+              continue;
+            }
+          }
+
+          let cruise_event = CruiseEvent {
+            path: path.to_string_lossy().to_string(),
+            kind: kind_string.to_string(),
+          };
+
+          let value: Value = cruise_event.into_value_with(ruby);
+          callback.call::<_, Value>((value,))?;
+        }
+      }
+      WaitResult::Timeout => {
+        continue;
+      }
+      WaitResult::Disconnected => {
+        return Err(Error::new(ruby.exception_runtime_error(), "Watcher channel disconnected unexpectedly"));
+      }
+    }
+  }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+  let module = ruby.get_inner(&MODULE);
+  let _ = ruby.get_inner(&EVENT_CLASS);
+
+  module.define_module_function("_watch", magnus::function!(watch, 5))?;
+
+  Ok(())
+}

data/lib/cruise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cruise
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 end

data/lib/cruise.rb

@@ -2,7 +2,33 @@
 
 require_relative "cruise/version"
 
+begin
+  ruby_version = RUBY_VERSION.split(".")[0..1].join(".")
+
+  begin
+    require "cruise/#{ruby_version}/cruise"
+  rescue LoadError
+    require "cruise/cruise"
+  end
+rescue LoadError => e
+  raise LoadError, "Failed to load Cruise native extension: #{e.message}"
+end
+
 module Cruise
-  class Error < StandardError; end
-  # Your code goes here...
+  DEFAULT_DEBOUNCE = 0.1
+
+  class << self
+    def watch(*args, glob: nil, debounce: DEFAULT_DEBOUNCE, only: nil, callback: nil, &block)
+      callback = block || callback
+      paths = args.flatten.grep(String)
+
+      raise ArgumentError, "Cruise.watch requires at least one path" if paths.empty?
+      raise ArgumentError, "Cruise.watch requires a block or callback" unless callback
+
+      glob_patterns = glob ? Array(glob) : []
+      only_kinds = only ? Array(only).map(&:to_s) : []
+
+      _watch(paths, callback, debounce.to_f, glob_patterns, only_kinds)
+    end
+  end
 end

metadata

@@ -1,24 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: cruise
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Marco Roth
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Cruise is a Rust-powered file system watcher with native OS integration.
   Uses FSEvents on macOS and inotify on Linux.
 email:
 - marco.roth@intergga.ch
 executables: []
-extensions: []
+extensions:
+- ext/cruise/extconf.rb
 extra_rdoc_files: []
 files:
+- Cargo.toml
+- LICENSE.txt
 - Rakefile
 - cruise.gemspec
+- ext/cruise/Cargo.toml
+- ext/cruise/extconf.rb
+- ext/cruise/src/lib.rs
 - lib/cruise.rb
 - lib/cruise/version.rb
 homepage: https://github.com/marcoroth/cruise
@@ -38,7 +58,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="