watchcat 0.2.0

data/ext/watchcat/src/lib.rs

@@ -0,0 +1,228 @@
+use crossbeam_channel::{select, unbounded};
+use magnus::{
+    block::{block_given, yield_value},
+    class::object,
+    define_module, function, method,
+    scan_args::{get_kwargs, scan_args},
+    Error, Module, Object, Value,
+};
+use notify::{Config, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher};
+use notify_debouncer_mini::new_debouncer;
+use std::{path::Path, time::Duration};
+
+mod event;
+use crate::event::WatchatEvent;
+
+#[magnus::wrap(class = "Watchcat::Watcher")]
+struct WatchcatWatcher {
+    tx: crossbeam_channel::Sender<bool>,
+    rx: crossbeam_channel::Receiver<bool>,
+}
+
+#[derive(Debug)]
+enum WatcherEnum {
+    #[allow(dead_code)]
+    Poll(PollWatcher),
+    #[allow(dead_code)]
+    Recommended(RecommendedWatcher),
+}
+
+impl WatchcatWatcher {
+    fn new() -> Self {
+        let (tx_executor, rx_executor) = unbounded::<bool>();
+        Self {
+            tx: tx_executor,
+            rx: rx_executor,
+        }
+    }
+
+    fn close(&self) {
+        self.tx.send(true).unwrap()
+    }
+
+    fn watch(&self, args: &[Value]) -> Result<bool, Error> {
+        if !block_given() {
+            return Err(Error::new(magnus::exception::arg_error(), "no block given"));
+        }
+
+        let (pathnames, recursive, force_polling, poll_interval, ignore_remove, debounce) = Self::parse_args(args)?;
+        let mode = if recursive {
+            RecursiveMode::Recursive
+        } else {
+            RecursiveMode::NonRecursive
+        };
+
+        if debounce >= 0 {
+            self.watch_with_debounce(pathnames, mode, ignore_remove, debounce)
+        } else {
+            self.watch_without_debounce(pathnames, mode, force_polling, poll_interval, ignore_remove)
+        }
+    }
+
+    fn watch_without_debounce(&self, pathnames: Vec<String>, mode: RecursiveMode, force_polling: bool, poll_interval: u64, ignore_remove: bool) -> Result<bool, Error> {
+        let (tx, rx) = unbounded();
+        // This variable is needed to keep `watcher` active.
+        let _watcher = match force_polling {
+            true => {
+                let delay = Duration::from_millis(poll_interval);
+                let config = notify::Config::default().with_poll_interval(delay);
+                let mut watcher = PollWatcher::new(tx, config)
+                    .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+                for pathname in &pathnames {
+                    let path = Path::new(pathname);
+                    watcher
+                        .watch(path, mode)
+                        .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+                }
+                WatcherEnum::Poll(watcher)
+            }
+            false => {
+                let mut watcher = RecommendedWatcher::new(tx, Config::default())
+                    .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+                for pathname in &pathnames {
+                    let path = Path::new(pathname);
+                    watcher
+                        .watch(path, mode)
+                        .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+                }
+                WatcherEnum::Recommended(watcher)
+            }
+        };
+
+        loop {
+            select! {
+                recv(self.rx) -> _res => {
+                    return Ok(true)
+                }
+                recv(rx) -> res => {
+                    match res {
+                        Ok(event) => {
+                            match event {
+                                Ok(event) => {
+                                    let paths = event
+                                        .paths
+                                        .iter()
+                                        .map(|p| p.to_string_lossy().into_owned())
+                                        .collect::<Vec<_>>();
+
+                                    if ignore_remove && matches!(event.kind, notify::event::EventKind::Remove(_)) {
+                                        continue;
+                                    }
+
+                                    yield_value::<(Vec<String>, Vec<String>, String), Value>(
+
+                                        (WatchatEvent::convert_kind(&event.kind), paths, format!("{:?}", event.kind))
+                                    )?;
+                                }
+                                Err(e) => {
+                                    return Err(
+                                        Error::new(magnus::exception::runtime_error(), e.to_string())
+                                    )
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            return Err(
+                                Error::new(magnus::exception::runtime_error(), e.to_string())
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn watch_with_debounce(&self, pathnames: Vec<String>, mode: RecursiveMode, ignore_remove: bool, debounce: i64) -> Result<bool, Error> {
+        let (tx, rx) = unbounded();
+        let mut debouncer = new_debouncer(Duration::from_millis(debounce.try_into().unwrap()), tx).unwrap();
+        for pathname in &pathnames {
+            let path = Path::new(pathname);
+            debouncer
+                .watcher()
+                .watch(path, mode)
+                .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+        }
+
+        loop {
+            select! {
+                recv(self.rx) -> _res => {
+                    return Ok(true)
+                }
+                recv(rx) -> res => {
+                    match res {
+                        Ok(events) => {
+                            match events {
+                                Ok(events) => {
+                                    events.iter().for_each(|event| {
+                                        if ignore_remove && !Path::new(&event.path).exists() {
+                                            return;
+                                        }
+
+                                        yield_value::<(Vec<String>, Vec<String>, String), Value>(
+                                            (vec![], vec![event.path.to_string_lossy().into_owned()], format!("{:?}", event.kind))
+                                        ).unwrap();
+                                    });
+                                }
+                                Err(e) => {
+                                    return Err(
+                                        Error::new(magnus::exception::runtime_error(), e.to_string())
+                                    )
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            return Err(
+                                Error::new(magnus::exception::runtime_error(), e.to_string())
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[allow(clippy::let_unit_value, clippy::type_complexity)]
+    fn parse_args(args: &[Value]) -> Result<(Vec<String>, bool, bool, u64, bool, i64), Error> {
+        type KwArgBool = Option<Option<bool>>;
+        type KwArgU64 = Option<Option<u64>>;
+        type KwArgi64 = Option<Option<i64>>;
+
+        let args = scan_args(args)?;
+        let (paths,): (Vec<String>,) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        let _: () = args.trailing;
+        let _: () = args.block;
+
+        let kwargs = get_kwargs(
+            args.keywords,
+            &[],
+            &["recursive", "force_polling", "poll_interval", "ignore_remove", "debounce"],
+        )?;
+        let (recursive, force_polling, poll_interval, ignore_remove, debounce): (KwArgBool, KwArgBool, KwArgU64, KwArgBool, KwArgi64) =
+            kwargs.optional;
+        let _: () = kwargs.required;
+        let _: () = kwargs.splat;
+
+        Ok((
+            paths,
+            recursive.flatten().unwrap_or(false),
+            force_polling.flatten().unwrap_or(false),
+            poll_interval.flatten().unwrap_or(200),
+            ignore_remove.flatten().unwrap_or(false),
+            debounce.flatten().unwrap_or(-1),
+        ))
+    }
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let module = define_module("Watchcat")?;
+
+    let watcher_class = module.define_class("Watcher", object())?;
+    watcher_class.define_singleton_method("new", function!(WatchcatWatcher::new, 0))?;
+    watcher_class.define_method("watch", method!(WatchcatWatcher::watch, -1))?;
+    watcher_class.define_method("close", method!(WatchcatWatcher::close, 0))?;
+
+    Ok(())
+}

data/lib/watchcat/client.rb

@@ -0,0 +1,26 @@
+module Watchcat
+  class Client
+    def initialize(uri, paths:, recursive:, force_polling:, poll_interval:, ignore_remove:, debounce:)
+      DRb.start_service
+      @watcher = Watchcat::Watcher.new
+      @server = DRbObject.new_with_uri(uri)
+      @paths = paths
+      @recursive = recursive
+      @force_polling = force_polling
+      @poll_interval = poll_interval
+      @ignore_remove = ignore_remove
+      @debounce = debounce
+    end
+
+    def run
+      @watcher.watch(
+        @paths,
+        recursive: @recursive,
+        force_polling: @force_polling,
+        poll_interval: @poll_interval,
+        ignore_remove: @ignore_remove,
+        debounce: @debounce
+      ) { |notification| @server.execute(notification) }
+    end
+  end
+end

data/lib/watchcat/event.rb

@@ -0,0 +1,63 @@
+require "watchcat/kind"
+
+module Watchcat
+  class Event
+    attr_reader :kind, :paths, :raw_kind, :event
+
+    def initialize(kinds, paths, raw_kind)
+      @paths = paths
+      @raw_kind = raw_kind
+      build_kind(kinds)
+    end
+
+    def deconstruct_keys(_keys)
+      { paths: @paths, event: @event }
+    end
+
+    private
+
+    def build_kind(kinds)
+      @kind = Watchcat::EventKind.new
+      @event = kinds.shift
+      if event
+        @kind.public_send("#{event}=", Object.const_get("Watchcat::#{event.capitalize}Kind").new)
+        send("build_#{event}_kind", kinds)
+      else
+        @kind.any = Watchcat::AnyKind.new
+        if File.directory?(@paths.first)
+          @kind.any.kind = "folder"
+        else
+          @kind.any.kind = "file"
+        end
+      end
+    end
+
+    def build_access_kind(kinds)
+      @kind.access.kind = kinds.shift
+
+      if @kind.access.open? || @kind.access.close?
+        @kind.access.access_mode = Watchcat::AccessMode.new(kinds.shift)
+      end
+    end
+
+    def build_create_kind(kinds)
+      @kind.create.kind = kinds.shift
+    end
+
+    def build_modify_kind(kinds)
+      @kind.modify.kind = kinds.shift
+
+      if @kind.modify.data_change?
+        @kind.modify.data_change = Watchcat::DataChange.new(kinds.shift)
+      elsif @kind.modify.metadata?
+        @kind.modify.metadata = Watchcat::MetadataKind.new(kinds.shift)
+      elsif @kind.modify.rename?
+        @kind.modify.rename = Watchcat::RenameMode.new(kinds.shift)
+      end
+    end
+
+    def build_remove_kind(kinds)
+      @kind.remove.kind = kinds.shift
+    end
+  end
+end

data/lib/watchcat/executor.rb

@@ -0,0 +1,64 @@
+require "drb"
+require "drb/unix"
+require_relative "server"
+require_relative "client"
+
+module Watchcat
+  class Executor
+    def initialize(paths, recursive:, force_polling:, poll_interval:, wait_until_startup:, ignore_remove:, debounce:, block:)
+      @service = nil
+      @child_pid = nil
+      @paths = paths
+      @recursive = recursive
+      @force_polling = force_polling
+      @poll_interval = poll_interval
+      @wait_until_startup = wait_until_startup
+      @ignore_remove = ignore_remove
+      @debounce = debounce
+      @block = block
+    end
+
+    def start
+      server = Server.new(@block)
+      @service = DRb.start_service("drbunix:", server)
+      client = nil
+      client = build_client if @wait_until_startup
+
+      @child_pid = fork do
+        client = build_client unless @wait_until_startup
+        Process.setproctitle("watchcat: watcher")
+        client.run
+      end
+
+      main = Process.pid
+      at_exit do
+        @exit_status = $!.status if $!.is_a?(SystemExit)
+        stop if Process.pid == main
+        exit @exit_status if @exit_status
+      end
+    end
+
+    def stop
+      begin
+        Process.kill(:KILL, @child_pid)
+      rescue Errno::ESRCH
+        # NOTE: We can ignore this error because there process is already dead.
+      end
+      @service.stop_service
+    end
+
+    private
+
+    def build_client
+      Client.new(
+        @service.uri,
+        paths: @paths,
+        recursive: @recursive,
+        force_polling: @force_polling,
+        poll_interval: @poll_interval,
+        debounce: @debounce,
+        ignore_remove: @ignore_remove
+      )
+    end
+  end
+end

data/lib/watchcat/kind.rb

@@ -0,0 +1,200 @@
+require "forwardable"
+
+module Watchcat
+  class EventKind
+    attr_accessor :access, :create, :modify, :remove, :any
+
+    def initialize
+      @access, @create, @modify, @remove, @any = nil, nil, nil, nil,nil
+    end
+
+    def access?
+      !@access.nil?
+    end
+
+    def create?
+      !@create.nil?
+    end
+
+    def modify?
+      !@modify.nil?
+    end
+
+    def remove?
+      !@remove.nil?
+    end
+
+    def any?
+      !@any.nil?
+    end
+  end
+
+  class AccessKind
+    extend Forwardable
+
+    attr_accessor :kind, :access_mode
+    delegate [:excute_mode?, :read_mode?, :write_mode?] => :@access_mode
+
+    def initialize
+      @kind, @access_mode = nil, nil
+    end
+
+    def read?
+      @kind == "read"
+    end
+
+    def open?
+      @kind == "open"
+    end
+
+    def close?
+      @kind == "close"
+    end
+  end
+
+  class CreateKind
+    attr_accessor :kind
+
+    def file?
+      @kind == "file"
+    end
+
+    def folder?
+      @kind == "folder"
+    end
+  end
+
+  class ModifyKind
+    extend Forwardable
+
+    attr_accessor :kind, :data_change, :metadata, :rename
+    delegate [:size?, :content?] => :@data_change
+    delegate [:access_time?, :write_time?, :permission?, :ownership?, :extended?] => :@metadata
+    delegate [:from?, :to?, :both?] => :@rename
+
+    def initialize
+      @kind, @data_change, @metadata, @rename = nil, nil, nil, nil
+    end
+
+    def data_change?
+      @kind == "data_change"
+    end
+
+    def metadata?
+      @kind == "metadata"
+    end
+
+    def rename?
+      @kind == "rename"
+    end
+  end
+
+  class RemoveKind
+    attr_accessor :kind
+
+    def file?
+      @kind == "file"
+    end
+
+    def folder?
+      @kind == "folder"
+    end
+  end
+
+  class AnyKind
+    attr_accessor :kind
+
+    def file?
+      @kind == "file"
+    end
+
+    def folder?
+      @kind == "folder"
+    end
+  end
+
+
+  class AccessMode
+    attr_accessor :mode
+
+    def initialize(mode)
+      @mode = mode
+    end
+
+    def execute_mode?
+      @mode == "execute"
+    end
+
+    def read_mode?
+      @mode == "read"
+    end
+
+    def write_mode?
+      @mode == "write"
+    end
+  end
+
+  class DataChange
+    attr_accessor :kind
+
+    def initialize(kind)
+      @kind = kind
+    end
+
+    def size?
+      @kind == "size"
+    end
+
+    def content?
+      @kind == "content"
+    end
+  end
+
+  class MetadataKind
+    attr_accessor :kind
+
+    def initialize(kind)
+      @kind = kind
+    end
+
+    def access_time?
+      @kind == "access_time"
+    end
+
+    def write_time?
+      @kind == "write_time"
+    end
+
+    def permission?
+      @kind == "permission"
+    end
+
+    def ownership?
+      @kind == "ownership"
+    end
+
+    def extended?
+      @kind == "extended"
+    end
+  end
+
+  class RenameMode
+    attr_accessor :mode
+
+    def initialize(mode)
+      @mode = mode
+    end
+
+    def from?
+      @mode == "from"
+    end
+
+    def to?
+      @mode == "to"
+    end
+
+    def both?
+      @mode == "both"
+    end
+  end
+end

data/lib/watchcat/server.rb

@@ -0,0 +1,14 @@
+require "watchcat/event"
+
+module Watchcat
+  class Server
+    def initialize(block)
+      @block = block
+    end
+
+    def execute(notification)
+      event = Watchcat::Event.new(notification[0], notification[1], notification[2])
+      @block.call(event)
+    end
+  end
+end

data/lib/watchcat/version.rb

@@ -0,0 +1,3 @@
+module Watchcat
+  VERSION = "0.2.0"
+end

data/lib/watchcat.rb

@@ -0,0 +1,37 @@
+require_relative "watchcat/version"
+require_relative "watchcat/executor"
+
+begin
+  require "watchcat/#{RUBY_VERSION.to_f}/watchcat"
+rescue LoadError
+  require "watchcat/watchcat"
+end
+
+module Watchcat
+  class << self
+    def watch(
+      paths,
+      recursive: true,
+      force_polling: false,
+      poll_interval: nil,
+      wait_until_startup: false,
+      ignore_remove: false,
+      debounce: -1,
+      &block
+    )
+      w =
+        Watchcat::Executor.new(
+          Array(paths),
+          recursive: recursive,
+          force_polling: force_polling,
+          poll_interval: poll_interval,
+          wait_until_startup: wait_until_startup,
+          ignore_remove: ignore_remove,
+          debounce: debounce,
+          block: block
+        )
+      w.start
+      w
+    end
+  end
+end

data/watchcat.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/watchcat/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "watchcat"
+  spec.version = Watchcat::VERSION
+  spec.authors = ["Yuji Yaginuma"]
+  spec.email = ["yuuji.yaginuma@gmail.com"]
+
+  spec.summary = "Simple filesystem notification library for Ruby. "
+  spec.homepage = "https://github.com/y-yagi/watchcat"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|benchmark)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/watchcat/extconf.rb"]
+
+  spec.add_dependency "rb_sys"
+  spec.add_dependency "drb"
+  spec.add_development_dependency "debug"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-retry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "ruby_memcheck"
+  spec.add_development_dependency "listen"
+end