io-watch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28d2d87eebbc0c7ba0750330239bdd1d00c8195ff8a93121ba13a8368b681730
+  data.tar.gz: 8528b998df129ca0da1f4ff7cbf3627721608bf4491ac7da41fb3a8b381d65cf
+SHA512:
+  metadata.gz: 7896b82cab31023f395aeb3bf9a588e31291b8d5ed2030f818377977e15dfb431a7ec80af2717ee252bff134816aea367c2099084747c09af16af62c58c174fe
+  data.tar.gz: e9f8f8a987490ace634ddd18eea1514657e12b0f945219063442750c16e53dc1f59e95b91c0ecb356e06ec863d2661a601069e611fe6ad3503a739737a01a2bf

data/ext/Makefile

@@ -0,0 +1,31 @@
+TARGET = io-watch
+CC = cc
+CFLAGS = -Wall -Wextra
+LDFLAGS = -framework CoreServices
+SOURCES = io/watch.c io/watch/fsevent.c
+OBJECTS = $(SOURCES:.c=.o)
+PREFIX = /Users/samuel/Developer/socketry/io-watch/ext
+
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(LDFLAGS) -o $@ $^
+
+# To create object files
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+# Clean Target
+clean:
+	rm -f $(TARGET) $(OBJECTS)
+
+install: $(TARGET)
+	@echo "Installing $(TARGET) to $(PREFIX)/bin"
+	mkdir -p $(PREFIX)/bin
+	install -m 755 $(TARGET) $(PREFIX)/bin
+
+uninstall:
+	@echo "Removing $(TARGET) from $(PREFIX)/bin"
+	rm -f $(PREFIX)/bin/$(TARGET)
+
+.PHONY: all clean install uninstall

data/ext/configure

@@ -0,0 +1,77 @@
+#!/bin/sh
+
+PREFIX=$(pwd)
+LDFLAGS=""
+SOURCES=""
+CC="${CC:-cc}"
+
+# Parse command line arguments
+for arg in "$@"; do
+	case $arg in
+		--prefix=*)
+			PREFIX="${arg#*=}"
+			shift
+			;;
+		*)
+			echo "Unknown option: $arg"
+			exit 1
+			;;
+	esac
+done
+
+OS="$(uname)"
+echo "Detected OS: $OS"
+
+# Generate Makefile based on the platform
+case "$OS" in
+	Darwin)
+		echo "Using FSEvents (macOS)"
+		LDFLAGS="-framework CoreServices"
+		SOURCES="io/watch.c io/watch/fsevent.c"
+		;;
+	Linux)
+		echo "Using inotify (Linux)"
+		SOURCES="io/watch.c io/watch/inotify.c"
+		;;
+	*)
+		echo "Unsupported platform: $OS"
+		exit 1
+		;;
+esac
+
+# Create the Makefile
+cat > Makefile <<EOF
+TARGET = io-watch
+CC = $CC
+CFLAGS = -Wall -Wextra
+LDFLAGS = $LDFLAGS
+SOURCES = $SOURCES
+OBJECTS = \$(SOURCES:.c=.o)
+PREFIX = $PREFIX
+
+all: \$(TARGET)
+
+\$(TARGET): \$(OBJECTS)
+	\$(CC) \$(LDFLAGS) -o \$@ \$^
+
+# To create object files
+%.o: %.c
+	\$(CC) \$(CFLAGS) -c \$< -o \$@
+
+# Clean Target
+clean:
+	rm -f \$(TARGET) \$(OBJECTS)
+
+install: \$(TARGET)
+	@echo "Installing \$(TARGET) to \$(PREFIX)/bin"
+	mkdir -p \$(PREFIX)/bin
+	install -m 755 \$(TARGET) \$(PREFIX)/bin
+
+uninstall:
+	@echo "Removing \$(TARGET) from \$(PREFIX)/bin"
+	rm -f \$(PREFIX)/bin/\$(TARGET)
+
+.PHONY: all clean install uninstall
+EOF
+
+echo "Configuration complete. Run 'make' to build the project."

data/ext/io/watch/fsevent.c

@@ -0,0 +1,107 @@
+#include "watch.h"
+
+#include <CoreServices/CoreServices.h>
+#include <dispatch/dispatch.h>
+#include <stdio.h>
+
+enum {
+	DEBUG = 0,
+};
+
+static
+int IO_Watch_path_prefix(const char *path, const char *prefix) {
+	size_t path_size = strlen(path);
+	size_t prefix_size = strlen(prefix);
+	
+	if (path_size < prefix_size) {
+		return 0;
+	}
+	
+	return strncmp(path, prefix, prefix_size) == 0;
+}
+
+static
+ssize_t IO_Watch_find_path(struct IO_Watch *watch, const char *path) {
+	size_t index = 0;
+	
+	while (index < watch->size) {
+		if (IO_Watch_path_prefix(path, watch->paths[index])) {
+			return index;
+		}
+		
+		index += 1;
+	}
+	
+	return -1;
+}
+
+// Function to handle filesystem events
+void IO_Watch_FSEvent_callback(
+	ConstFSEventStreamRef streamRef,
+	void *context,
+	size_t numberOfEvents,
+	void *eventData,
+	const FSEventStreamEventFlags eventFlags[],
+	const FSEventStreamEventId eventIds[]) {
+	
+	const char **eventPaths = (const char**)eventData;
+	struct IO_Watch *watch = context;
+	
+	for (size_t i = 0; i < numberOfEvents; i++) {
+		if (DEBUG) fprintf(stderr, "Event: %s\n", eventPaths[i]);
+		
+		// Find the index of the path in the paths array
+		ssize_t index = IO_Watch_find_path(watch, eventPaths[i]);
+		
+		if (index != -1) {
+			// Output event data as newline-delimited JSON
+			printf("{\"index\":%zu,\"flags\":%u,\"id\":%llu}\n", index, eventFlags[i], eventIds[i]);
+		} else {
+			fprintf(stderr, "Path not found in paths array: %s\n", eventPaths[i]);
+		}
+	}
+	
+	fflush(stdout);
+}
+
+void IO_Watch_run(struct IO_Watch *watch) {
+	CFStringRef *pathsToWatch = malloc(sizeof(CFStringRef) * watch->size);
+	for (size_t i = 0; i < watch->size; i++) {
+		pathsToWatch[i] = CFStringCreateWithCString(NULL, watch->paths[i], kCFStringEncodingUTF8);
+	}
+	
+	CFArrayRef pathsToWatchArray = CFArrayCreate(NULL, (const void **)pathsToWatch, watch->size, &kCFTypeArrayCallBacks);
+	
+	FSEventStreamContext context = {0, watch, NULL, NULL, NULL};
+	
+	FSEventStreamRef stream;
+	CFAbsoluteTime latency = watch->latency;
+	
+	stream = FSEventStreamCreate(
+		NULL,
+		&IO_Watch_FSEvent_callback,
+		&context,
+		pathsToWatchArray,
+		kFSEventStreamEventIdSinceNow,
+		latency,
+		kFSEventStreamCreateFlagNone
+	);
+	
+	dispatch_queue_t queue = dispatch_queue_create("com.example.fsevents.queue", NULL);
+	FSEventStreamSetDispatchQueue(stream, queue);
+	FSEventStreamStart(stream);
+	
+	printf("{\"status\":\"started\"}\n");
+	fflush(stdout);
+	
+	dispatch_main();
+	
+	FSEventStreamStop(stream);
+	FSEventStreamInvalidate(stream);
+	FSEventStreamRelease(stream);
+	for (size_t i = 0; i < watch->size; i++) {
+		CFRelease(pathsToWatch[i]);
+	}
+	free(pathsToWatch);
+	CFRelease(pathsToWatchArray);
+}

data/ext/io/watch/inotify.c

@@ -0,0 +1,229 @@
+#include "watch.h"
+
+#include <sys/inotify.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <dirent.h>
+#include <string.h>
+#include <sys/stat.h>
+
+enum {
+	DEBUG = 0,
+};
+
+struct IO_Watch_Watch {
+	int watch_descriptor;
+	char *path;
+	int index;
+};
+
+struct IO_Watch_Watch_Array {
+	size_t size;
+	size_t capacity;
+	struct IO_Watch_Watch *watches;
+};
+
+#define BUFFER_SIZE (10 * (sizeof(struct inotify_event) + NAME_MAX + 1))
+
+void IO_Watch_Watch_Array_initialize(struct IO_Watch_Watch_Array *array) {
+	array->size = 0;
+	array->capacity = 16;
+	array->watches = malloc(array->capacity * sizeof(struct IO_Watch_Watch));
+	if (!array->watches) {
+		perror("malloc");
+		exit(EXIT_FAILURE);
+	}
+}
+
+void IO_Watch_Watch_Array_resize(struct IO_Watch_Watch_Array *array) {
+	array->capacity *= 2;
+	array->watches = realloc(array->watches, array->capacity * sizeof(struct IO_Watch_Watch));
+	if (!array->watches) {
+		perror("realloc");
+		exit(EXIT_FAILURE);
+	}
+}
+
+void IO_Watch_Watch_Array_add(struct IO_Watch_Watch_Array *array, int watch_descriptor, char *path, int index) {
+	if (array->size == array->capacity) {
+		IO_Watch_Watch_Array_resize(array);
+	}
+	array->watches[array->size].watch_descriptor = watch_descriptor;
+	array->watches[array->size].path = path;
+	array->watches[array->size].index = index;
+	array->size++;
+}
+
+ssize_t IO_Watch_Watch_Array_find(struct IO_Watch_Watch_Array *array, int watch_descriptor) {
+	for (size_t i = 0; i < array->size; i++) {
+		if (array->watches[i].watch_descriptor == watch_descriptor) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+void IO_Watch_Watch_Array_watch(int fd, struct IO_Watch_Watch_Array *watch_array, char *path, int index) {
+	int watch_descriptor = inotify_add_watch(fd, path, IN_ALL_EVENTS);
+	if (watch_descriptor == -1) {
+		perror("inotify_add_watch");
+		exit(EXIT_FAILURE);
+	}
+	
+	IO_Watch_Watch_Array_add(watch_array, watch_descriptor, path, index);
+	
+	if (DEBUG) fprintf(stderr, "Added watch: %s\n", path);
+}
+
+void IO_Watch_Watch_Array_scan(int fd, struct IO_Watch_Watch_Array *watch_array, const char *root, int index) {
+	DIR *dir = opendir(root);
+	if (!dir) {
+		perror("opendir");
+		return;
+	}
+	
+	struct dirent *entry;
+	while ((entry = readdir(dir)) != NULL) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+			continue;
+		}
+		
+		size_t size = strlen(root) + 1 + strlen(entry->d_name) + 1;
+		char *path = malloc(size);
+		snprintf(path, size, "%s/%s", root, entry->d_name);
+
+		struct stat statbuf;
+		if (stat(path, &statbuf) == -1) {
+			perror("stat");
+			continue;
+		}
+
+		if (S_ISDIR(statbuf.st_mode)) {
+			IO_Watch_Watch_Array_watch(fd, watch_array, path, index);
+			IO_Watch_Watch_Array_scan(fd, watch_array, path, index);
+		} else {
+			free(path);
+		}
+	}
+
+	closedir(dir);
+}
+
+void IO_Watch_Watch_Array_add_subdirectory(int fd, struct IO_Watch_Watch_Array *watch_array, struct IO_Watch_Watch watch, const char *name) {
+	size_t size = strlen(watch.path) + 1 + strlen(name) + 1;
+	char *path = malloc(size);
+	snprintf(path, size, "%s/%s", watch.path, name);
+
+	IO_Watch_Watch_Array_watch(fd, watch_array, path, watch.index);
+	IO_Watch_Watch_Array_scan(fd, watch_array, path, watch.index);
+}
+
+void IO_Watch_Watch_Array_remove(int fd, struct IO_Watch_Watch_Array *watch_array, size_t index) {
+	struct IO_Watch_Watch watch = watch_array->watches[index];
+	
+	if (DEBUG) fprintf(stderr, "Removing watch: %s\n", watch.path);
+	
+	inotify_rm_watch(fd, watch.watch_descriptor);
+	free(watch.path);
+	
+	// Replace the removed item with the last one.
+	watch_array->size--;
+	if (index < watch_array->size) {
+		watch_array->watches[index] = watch_array->watches[watch_array->size];
+	}
+}
+
+static
+void IO_Watch_INotify_print_event(struct inotify_event *event) {
+	fprintf(stderr, "Event: wd=%d", event->wd);
+	
+	uint32_t mask = event->mask;
+	if (mask & IN_ACCESS) fprintf(stderr, " ACCESS");
+	if (mask & IN_MODIFY) fprintf(stderr, " MODIFY");
+	if (mask & IN_ATTRIB) fprintf(stderr, " ATTRIB");
+	if (mask & IN_CLOSE_WRITE) fprintf(stderr, " CLOSE_WRITE");
+	if (mask & IN_CLOSE_NOWRITE) fprintf(stderr, " CLOSE_NOWRITE");
+	if (mask & IN_OPEN) fprintf(stderr, " OPEN");
+	if (mask & IN_MOVED_FROM) fprintf(stderr, " MOVED_FROM");
+	if (mask & IN_MOVED_TO) fprintf(stderr, " MOVED_TO");
+	if (mask & IN_CREATE) fprintf(stderr, " CREATE");
+	if (mask & IN_DELETE) fprintf(stderr, " DELETE");
+	if (mask & IN_DELETE_SELF) fprintf(stderr, " DELETE_SELF");
+	if (mask & IN_MOVE_SELF) fprintf(stderr, " MOVE_SELF");
+	if (mask & IN_UNMOUNT) fprintf(stderr, " UNMOUNT");
+	if (mask & IN_Q_OVERFLOW) fprintf(stderr, " Q_OVERFLOW");
+	if (mask & IN_IGNORED) fprintf(stderr, " IGNORED");
+	if (mask & IN_ISDIR) fprintf(stderr, " ISDIR");
+	if (mask & IN_ONESHOT) fprintf(stderr, " ONESHOT");
+	if (mask & IN_ALL_EVENTS) fprintf(stderr, " ALL_EVENTS");
+	
+	if (event->len > 0) {
+		fprintf(stderr, " name=%s", event->name);
+	}
+	
+	fprintf(stderr, "\n");
+}
+
+void IO_Watch_run(struct IO_Watch *watch) {
+	int fd = inotify_init1(IN_NONBLOCK);
+	if (fd == -1) {
+		perror("inotify_init1");
+		exit(EXIT_FAILURE);
+	}
+
+	struct IO_Watch_Watch_Array watch_array;
+	IO_Watch_Watch_Array_initialize(&watch_array);
+
+	for (size_t i = 0; i < watch->size; i++) {
+		char *path = strdup(watch->paths[i]);
+		
+		IO_Watch_Watch_Array_watch(fd, &watch_array, path, i);
+		IO_Watch_Watch_Array_scan(fd, &watch_array, path, i);
+	}
+
+	printf("{\"status\":\"started\"}\n");
+	fflush(stdout);
+
+	char buffer[BUFFER_SIZE] __attribute__ ((aligned(8)));
+	
+	while (1) {
+		ssize_t result = read(fd, buffer, BUFFER_SIZE);
+		if (result == -1 && errno != EAGAIN) {
+			perror("read");
+			exit(EXIT_FAILURE);
+		}
+
+		for (ssize_t offset = 0; offset < result;) {
+			struct inotify_event *event = (struct inotify_event *) &buffer[offset];
+			if (DEBUG) IO_Watch_INotify_print_event(event);
+			
+			ssize_t index = IO_Watch_Watch_Array_find(&watch_array, event->wd);
+
+			if (index != -1) {
+				printf("{\"index\":%d,\"mask\":%u}\n", watch_array.watches[index].index, event->mask);
+
+				// If a new directory is created, add a watch for it
+				if (event->mask & IN_CREATE && event->mask & IN_ISDIR) {
+					IO_Watch_Watch_Array_add_subdirectory(fd, &watch_array, watch_array.watches[index], event->name);
+				} else if (event->mask & IN_IGNORED) {
+					IO_Watch_Watch_Array_remove(fd, &watch_array, index);
+				}
+			} else {
+				fprintf(stderr, "Watch descriptor not found: %d\n", event->wd);
+			}
+
+			offset += sizeof(struct inotify_event) + event->len;
+		}
+		fflush(stdout);
+	}
+
+	for (size_t i = 0; i < watch_array.size; i++) {
+		inotify_rm_watch(fd, watch_array.watches[i].watch_descriptor);
+		free(watch_array.watches[i].path);
+	}
+	close(fd);
+	free(watch_array.watches);
+}

data/ext/io/watch/watch.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stddef.h>
+#include <sys/types.h>
+
+struct IO_Watch {
+	float latency;
+	
+	size_t size;
+	const char **paths;
+};
+
+void IO_Watch_run(struct IO_Watch *watch);

data/ext/io/watch.c

@@ -0,0 +1,45 @@
+#include "watch/watch.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+	DEBUG = 0,
+};
+
+int main(int argc, char **argv) {
+	if (argc < 2) {
+		fprintf(stderr, "Usage: %s <directory_to_watch> [<directory_to_watch> ...]\n", argv[0]);
+		return 1;
+	}
+
+	struct IO_Watch watch;
+	watch.latency = 0.1;
+	watch.size = argc - 1;
+	watch.paths = (const char **) &argv[1];
+	
+	char * latency = getenv("IO_WATCH_LATENCY");
+	if (latency != NULL) {
+		watch.latency = atof(latency);
+	}
+	
+	for (size_t i = 0; i < watch.size; i++) {
+		char *real_path = realpath(watch.paths[i], NULL);
+		if (real_path == NULL) {
+			fprintf(stderr, "Error: realpath failed for %s\n", watch.paths[i]);
+			return 1;
+		} else {
+			if (DEBUG) fprintf(stderr, "Watching: %s\n", real_path);
+			watch.paths[i] = real_path;
+		}
+	}
+
+	IO_Watch_run(&watch);
+
+	for (size_t i = 0; i < watch.size; i++) {
+		free((void *) watch.paths[i]);
+	}
+
+	return 0;
+}

data/lib/io/watch/monitor.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'json'
+
+class IO
+	module Watch
+		# Represents a list of roots to watch for changes.
+		class Monitor
+			def self.command_path
+				if extensions_path = Gem.loaded_specs['io-watch']&.extensions_dir
+					if File.exist?(extensions_path)
+						return File.join(extensions_path, 'io-watch')
+					end
+				end
+				
+				return File.join(__dir__, '../../../ext/bin/io-watch')
+			end
+			
+			COMMAND_PATH = self.command_path
+			
+			# Initialize the monitor with a list of roots to watch.
+			#
+			# The roots are the paths that will be watched for changes, recursively.
+			#
+			# @parameter roots [Array(String)] The list of root directories to watch. Changes to these directories, and their children, recursively, will be reported.
+			# @parameter latency [Float] The latency to use when watching the filesystem.
+			def initialize(roots, latency = 0.1)
+				@roots = roots
+				@latency = latency
+			end
+			
+			# Run the monitor and yield events as they occur.
+			#
+			# The values yielded are hashes with at least the following:
+			# - `:root` - The root path that the event occurred in.
+			#
+			# There may be other platform specific keys present.
+			#
+			# @yields {|event| ...} Yielded for each event that occurs.
+			#   @parameter event [Hash] The event that occurred.
+			def run
+				environment = {'IO_WATCH_LATENCY' => @latency.to_s}
+				IO.pipe do |input, output|
+					pid = Process.spawn(environment, self.class.command_path, *@roots, out: output)
+					output.close
+					
+					input.each_line do |line|
+						event = JSON.parse(line, symbolize_names: true)
+						
+						if index = event[:index]
+							event[:root] = @roots[index]
+						end
+						
+						yield event
+					end
+				ensure
+					Process.kill('TERM', pid) if pid
+				end
+			end
+		end
+	end
+end

data/lib/io/watch/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+class IO
+	module Watch
+		VERSION = '0.1.0'
+	end
+end

data/lib/io/watch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'watch/version'
+require_relative 'watch/monitor'
+
+class IO
+	module Watch
+		def self.new(...)
+			Monitor.new(...)
+		end
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2024, by Samuel Williams.  
+
+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,29 @@
+# IO::Watch
+
+Monitor the file-system for changes.
+
+[![Development Status](https://github.com/socketry/io-watch/workflows/Test/badge.svg)](https://github.com/socketry/io-watch/actions?workflow=Test)
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/io-watch/) for more details.
+
+  - [Getting Started](https://socketry.github.io/io-watch/guides/getting-started/index) - This guide explains how to use the `io-watch` gem for watching files and directories for changes.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributions to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed. All contributors must agree to this document for their contributions to be accepted.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: io-watch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 2024-06-28 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables: []
+extensions:
+- ext/configure
+extra_rdoc_files: []
+files:
+- ext/Makefile
+- ext/bin/io-watch
+- ext/configure
+- ext/io-watch
+- ext/io/watch.c
+- ext/io/watch.o
+- ext/io/watch/fsevent.c
+- ext/io/watch/fsevent.o
+- ext/io/watch/inotify.c
+- ext/io/watch/watch.h
+- lib/io/watch.rb
+- lib/io/watch/monitor.rb
+- lib/io/watch/version.rb
+- license.md
+- readme.md
+homepage: https://github.com/socketry/io-watch
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/io-watch/
+  source_code_uri: https://github.com/socketry/io-watch.git
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A tool for watching changes to the filesystem.
+test_files: []