fswatch-rb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '068664ab465511d6e4efc65056b4647b5782b2ac2918031a7229d2aa58c757da'
+  data.tar.gz: 23dd203bae6b26f25ddd9d3f2d27016ef8389dbb10d3ecf0ff4a22673704e076
+SHA512:
+  metadata.gz: 6554d417c403504051503bb0e646f8d5d41b5cb7aa52bb732a29dfdcbf8d72fbe807ea828c1aa29ecba5b781d4afe8f1579ae21458b31c9d7b41a4571238c1ac
+  data.tar.gz: 47a793d84e9dad183bf68710203655fcffccfb7b4149df776ade6bf09ef3dc20183d8d1a18bb650acc9205df1ed9f17dba3eaa22a65d5139040136af67fe7ec5

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# exclude compiled binary
+*.bundle
+
+# exclude compiled gem
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    fswatch-rb (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rake-compiler (1.0.4)
+      rake
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  fswatch-rb!
+  rake (~> 10.0)
+  rake-compiler (~> 1.0)
+  rspec (~> 3.7)
+
+BUNDLED WITH
+   1.16.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Igor Yamolov
+
+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,76 @@
+# fswatch-rb
+
+fswatch-rb is binding for multi-platform fswatch library.
+
+https://github.com/emcrisostomo/fswatch/
+
+## Installation
+
+First you need to install fswatch >= 1.11.3
+
+```bash
+$ brew install fswatch
+```
+
+Then add this line to your application's Gemfile:
+
+```ruby
+gem 'fswatch-rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fswatch-rb
+
+## Usage
+
+```ruby
+require 'fswatch'
+
+events_array = []
+
+watcher = Fswatch::Watcher.new(
+  path: '~/my/awesome/project/directory/',
+  event_flags: [:created, :updated, :is_file, :renamed, :removed],
+  filters: { # global filters, high-perfomance
+    /\.tmp$/ix => :exclude, # if file ends with .tmp it will be ignored
+    /\(.rb|.slim)$/x => :include  # include only .rb and .slim files
+    # Please note these reg exps are executed OUTSIDE ruby and not by ruby regexp implementation, so be careful
+  },
+  latency: 0.1, # 100ms
+  recursive: true,
+  follow_symlinks: true,
+)
+
+watcher.watch do |file, timestamp, flags|
+  puts "File #{file} has been changed at #{timestamp} with #{flags}"
+end
+
+# local filename filter, low-perfomance
+watcher.watch(match: /\.css$/) do |file, timestamp, flags|
+  puts "CSS File #{file} has been changed!"
+end
+
+watcher.start! # this will spawn new thread in background
+
+watcher.running? # => true
+
+# ... do evil stuff ...
+
+watcher.stop!
+
+watcher.running? # => false
+
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/t3hk0d3/fswatch-rb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rake/extensiontask'
+
+RSpec::Core::RakeTask.new(:spec)
+
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'fswatch'               
+  ext.ext_dir = 'ext/fswatch'        
+  ext.lib_dir = 'lib/fswatch'                                                               
+end
+
+task :default => [:compile, :spec]

data/ext/fswatch/Makefile

@@ -0,0 +1,264 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@ :)
+ECHO = $(ECHO1:0=@ echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /Users/tehkode/.rubies/ruby-2.4.2/include/ruby-2.4.0
+hdrdir = $(topdir)
+arch_hdrdir = /Users/tehkode/.rubies/ruby-2.4.2/include/ruby-2.4.0/x86_64-darwin16
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/Users/tehkode/.rubies/ruby-2.4.2
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(SDKROOT)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = clang
+CXX = clang++
+LIBRUBY = $(LIBRUBY_A)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = 
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static -framework CoreFoundation
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+CSRCFLAG = $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   = $(optflags) $(debugflags) $(warnflags)
+cxxflags = $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wno-tautological-compare -Wno-parentheses-equality -Wno-constant-logical-operand -Wno-self-assign -Wunused-variable -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration -Wdivision-by-zero -Wdeprecated-declarations -Wextra-tokens
+CCDLFLAGS = -fno-common
+CFLAGS   = $(CCDLFLAGS)  -O3 -Wno-error=shorten-64-to-32  -pipe $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -I/usr/local/include -I/usr/include -I/Users/tehkode/.rubies/ruby-2.4.2/include  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) -std=c++11  $(ARCH_FLAG)
+ldflags  = -L. -L/Users/tehkode/.rubies/ruby-2.4.2/lib  -fstack-protector -L/usr/local/lib
+dldflags = -L/Users/tehkode/.rubies/ruby-2.4.2/lib  -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-darwin16
+sitearch = $(arch)
+ruby_version = 2.4.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+libpath = . $(libdir) /usr/local/lib /usr/lib
+LIBPATH =  -L. -L$(libdir) -L/usr/local/lib -L/usr/lib
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = /fswatch
+LOCAL_LIBS = 
+LIBS =  -lfswatch  -lpthread -ldl -lobjc 
+ORIG_SRCS = callback.c enums.c fswatch.c listener.c
+SRCS = $(ORIG_SRCS) enums.c callback.c fswatch.c listener.c
+OBJS = enums.o callback.o fswatch.o listener.o
+HDRS = $(srcdir)/fswatch.h
+LOCAL_HDRS = 
+TARGET = fswatch
+TARGET_NAME = fswatch
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+TARGET_SO_DIR =
+TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
+CLEANLIBS     = $(TARGET_SO) 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.sitearchdir.-.fswatch.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb do-install-rb install-rb-default
+install-rb-default: pre-install-rb-default do-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+do-install-rb:
+do-install-rb-default:
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TIMESTAMP_DIR)/.sitearchdir.-.fswatch.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+$(TARGET_SO): $(OBJS) Makefile
+	$(ECHO) linking shared-object fswatch/$(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+	$(Q) $(POSTLINK)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/fswatch/callback.c

@@ -0,0 +1,56 @@
+#include <stdint.h>
+
+#include "fswatch.h"
+
+
+void* fswatch_start_monitor_no_gvl(void* data) {
+  FSW_HANDLE handle = (FSW_HANDLE)data;
+  FSW_STATUS status = fsw_start_monitor(handle);
+
+  return (void *)(intptr_t)status; // return integer hidden as pointer
+}
+
+void* fswatch_callback_handler_with_gvl(void* data) {
+  FSW_EVENT_CONTEXT *context = data;
+
+  VALUE rb_aEvents = rb_ary_new2(context->event_num);
+
+  for (int i = 0 ; i < context->event_num ; i++) {
+    const fsw_cevent event = context->events[i];
+
+    VALUE rb_aEvent = rb_ary_new2(2 + event.flags_num);
+
+    rb_ary_push(rb_aEvent, rb_str_new2(event.path));
+    rb_ary_push(rb_aEvent, INT2NUM(event.evt_time));
+
+    for (int c = 0 ; c < event.flags_num ; c++) {
+      rb_ary_push(rb_aEvent, fswatch_event_name(event.flags[c]));
+    }
+
+    rb_ary_push(rb_aEvents, rb_aEvent);
+  }
+
+  VALUE rb_proc_obj = rb_ivar_get(context->object, rb_intern("callback"));
+
+  rb_proc_call(rb_proc_obj, rb_ary_new_from_args(1, rb_aEvents));
+
+  return NULL;
+}
+
+void fswatch_interrupt_monitor_no_gvl(void* data) {
+  FSW_HANDLE handle = (FSW_HANDLE)data;
+  FSW_STATUS status = fsw_stop_monitor(handle);
+
+  if (status != FSW_OK) {
+    rb_raise(rb_eRuntimeError, "Failed to interrupt monitor - err: %d", status);
+  }
+
+}
+
+void fswatch_callback_handler_no_gvl(fsw_cevent const *const events,
+                                      const unsigned int event_num,
+                                      void *data) {
+  FSW_EVENT_CONTEXT context = { .events = events, .event_num = event_num, .object = (VALUE)data };
+
+  rb_thread_call_with_gvl(fswatch_callback_handler_with_gvl, &context);
+}

data/ext/fswatch/configure.c

@@ -0,0 +1,192 @@
+#include "fswatch.h"
+
+#define REGEXP_IGNORECASE (1 << 0) // 1
+#define REGEXP_EXTENDED   (1 << 1) // 2
+
+static void fswatch_add_path(FSW_HANDLE handle, VALUE rb_settings) {
+  VALUE rb_path = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("path")));
+
+  VALUE path_arr;
+
+  switch (TYPE(rb_path)) {
+    case T_STRING:
+      path_arr = rb_ary_new_from_args(1, rb_path);
+      break;
+    case T_ARRAY:
+      path_arr = rb_path;
+      break;
+    default:
+      rb_raise(rb_eTypeError, "path is not valid");
+      break;
+  }
+
+  long length = RARRAY_LEN(path_arr);
+
+  for ( long i = 0 ; i < length ; i++ ){ 
+    VALUE rb_arr_item = rb_ary_entry(path_arr, i);
+
+    char* path_cstr = StringValueCStr(rb_arr_item);
+
+
+    if(fsw_add_path(handle, path_cstr) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Unable to monitor specified path - '%s'", path_cstr);
+    }
+  }
+}
+
+static void fswatch_add_properties(FSW_HANDLE handle, VALUE rb_settings) {
+  VALUE rb_properties = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("properties")));
+
+  if (rb_properties == Qnil) {
+    return;
+  }
+
+  Check_Type(rb_properties, T_HASH);
+
+  VALUE rb_property_keys = rb_funcall(rb_properties, rb_intern("keys"), 0);
+
+  long arr_len = RARRAY_LEN(rb_property_keys);
+  for ( long i = 0 ; i < arr_len ; i++ ){ 
+    VALUE rb_key = rb_ary_entry(rb_property_keys, i);
+    VALUE rb_value = rb_hash_fetch(rb_properties, rb_key);
+
+    if (TYPE(rb_key) == T_SYMBOL) {
+      rb_key = rb_sym2str(rb_key);
+    }
+
+    Check_Type(rb_key, T_STRING);
+    Check_Type(rb_value, T_STRING);
+
+    char* key_cstr = StringValueCStr(rb_key);
+    char* value_cstr = StringValueCStr(rb_value);
+
+
+    if(fsw_add_property(handle, key_cstr, value_cstr) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Unable to add specified property - '%s' = '%s'", key_cstr, value_cstr);
+    }
+  }
+}
+
+static void fswatch_add_event_type_filters(FSW_HANDLE handle, VALUE rb_settings) {
+  VALUE rb_event_types = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("event_flags")));
+
+  if (rb_event_types == Qnil) {
+    return;
+  }
+
+  Check_Type(rb_event_types, T_ARRAY);
+
+  long arr_len = RARRAY_LEN(rb_event_types);
+  for ( long i = 0 ; i < arr_len ; i++ ){ 
+    VALUE rb_event_type = rb_ary_entry(rb_event_types, i);
+
+    fsw_event_type_filter filter = { .flag = fswatch_event_type(rb_event_type) };
+
+    VALUE rb_str = rb_sym2str(rb_event_type);
+
+
+    if (fsw_add_event_type_filter(handle, filter) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Unable to event type filter - '%s' (%d)", StringValueCStr(rb_str), filter.flag);
+    }
+  }
+}
+
+static void fswatch_add_monitor_filters(FSW_HANDLE handle, VALUE rb_settings) {
+  VALUE rb_monitor_filters = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("filters")));
+
+  if (rb_monitor_filters == Qnil) {
+    return;
+  }
+
+  Check_Type(rb_monitor_filters, T_HASH);
+
+  VALUE rb_monitor_keys = rb_funcall(rb_monitor_filters, rb_intern("keys"), 0);
+
+  long arr_len = RARRAY_LEN(rb_monitor_keys);
+  for ( long i = 0 ; i < arr_len ; i++ ){ 
+    VALUE rb_key = rb_ary_entry(rb_monitor_keys, i);
+    VALUE rb_value = rb_hash_fetch(rb_monitor_filters, rb_key);
+
+    Check_Type(rb_key, T_REGEXP);
+    Check_Type(rb_value, T_SYMBOL);
+
+    VALUE rb_regexp = RREGEXP_SRC(rb_key);
+    int options = rb_reg_options(rb_key);
+
+    enum fsw_filter_type filter_type;
+
+    if (SYM2ID(rb_value) == rb_intern("exclude")) {
+      filter_type = filter_exclude;
+    } else if (SYM2ID(rb_value) == rb_intern("include")) {
+      filter_type = filter_include;
+    } else {
+      VALUE rb_str = rb_sym2str(rb_value);
+      rb_raise(rb_eRuntimeError, "Unknown filter type - '%s'", StringValueCStr(rb_str));
+    }
+
+    const fsw_cmonitor_filter filter = {
+      .text           = StringValueCStr(rb_regexp),
+      .type           = filter_type,
+      .case_sensitive = (options & REGEXP_IGNORECASE) == 0,
+      .extended       = (options & REGEXP_EXTENDED)   != 0
+    };
+
+
+    if(fsw_add_filter(handle, filter) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Unable to path filter - '%s' => '%s'", filter.text, StringValueCStr(rb_value));
+    }
+  }
+}
+
+void fswatch_configure(FSW_HANDLE handle, VALUE rb_settings) {
+  fswatch_add_path(handle, rb_settings);
+  fswatch_add_properties(handle, rb_settings);
+
+  fswatch_add_event_type_filters(handle, rb_settings);
+  fswatch_add_monitor_filters(handle, rb_settings);
+
+  VALUE rb_latency = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("latency")));
+  if (rb_latency != Qnil) {
+    Check_Type(rb_latency, T_FLOAT);
+
+
+    if (fsw_set_latency(handle, NUM2DBL(rb_latency)) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Failed to set latency = %0.3f", NUM2DBL(rb_latency));
+    }
+  }
+
+  VALUE rb_allow_overflow = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("allow_overflow")));
+  if (rb_allow_overflow != Qnil) {
+
+    if (fsw_set_allow_overflow(handle, rb_allow_overflow != Qfalse) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Failed to set overflow mode = %d", rb_allow_overflow != Qfalse);
+    }
+  }
+
+  VALUE rb_recursive = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("recursive")));
+  if (rb_recursive != Qnil) {
+    if (fsw_set_recursive(handle, rb_recursive != Qfalse) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Failed to set recursive mode = %d", rb_recursive != Qfalse);
+    }
+  }
+
+  VALUE rb_directory_only = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("directory_only")));
+  if (rb_directory_only != Qnil) {
+    if (fsw_set_directory_only(handle, rb_directory_only != Qfalse) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Failed to set directory-only mode = %d", rb_directory_only != Qfalse);
+    }
+  }
+
+  VALUE rb_follow_symlinks = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("follow_symlinks")));
+  if (rb_follow_symlinks != Qnil) {
+    if (fsw_set_directory_only(handle, rb_follow_symlinks != Qfalse) != FSW_OK) {
+      rb_raise(rb_eRuntimeError, "Failed to set follow-symlinks mode = %d", rb_follow_symlinks != Qfalse);
+    }
+  }
+
+  VALUE rb_verbose = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("debug")));
+  if (rb_verbose != Qnil) {
+    fsw_set_verbose(rb_verbose != Qfalse);
+  }
+
+}

data/ext/fswatch/enums.c

@@ -0,0 +1,95 @@
+#include "fswatch.h"
+
+VALUE fswatch_event_name(enum fsw_event_flag flag) {
+  ID rb_idFlagName;
+
+  switch (flag) {
+    case NoOp:              rb_idFlagName = rb_intern("no_op"); break;
+    case PlatformSpecific:  rb_idFlagName = rb_intern("platform_specific"); break;
+    case Created:           rb_idFlagName = rb_intern("created"); break;
+    case Updated:           rb_idFlagName = rb_intern("updated"); break;
+    case Removed:           rb_idFlagName = rb_intern("removed"); break;
+    case Renamed:           rb_idFlagName = rb_intern("renamed"); break;
+    case OwnerModified:     rb_idFlagName = rb_intern("owner_modified"); break;
+    case AttributeModified: rb_idFlagName = rb_intern("attribute_modified"); break;
+    case MovedFrom:         rb_idFlagName = rb_intern("moved_from"); break;
+    case MovedTo:           rb_idFlagName = rb_intern("moved_to"); break;
+    case IsFile:            rb_idFlagName = rb_intern("is_file"); break;
+    case IsDir:             rb_idFlagName = rb_intern("is_dir"); break;
+    case IsSymLink:         rb_idFlagName = rb_intern("is_symlink"); break;
+    case Link:              rb_idFlagName = rb_intern("link"); break;
+    case Overflow:          rb_idFlagName = rb_intern("overflow"); break;
+    default:
+      rb_idFlagName = rb_intern("unknown");
+  }
+
+  return ID2SYM(rb_idFlagName);
+}
+
+enum fsw_event_flag fswatch_event_type(VALUE rb_flag) {
+  ID rb_idFlagName = rb_to_id(rb_flag);
+
+  if ( rb_idFlagName == rb_intern("no_op") ) {
+    return NoOp;
+  } else if ( rb_idFlagName == rb_intern("platform_specific") ) {
+    return PlatformSpecific;
+  } else if ( rb_idFlagName == rb_intern("created") ) {
+    return Created;
+  } else if ( rb_idFlagName == rb_intern("updated") ) {
+    return Updated;
+  } else if ( rb_idFlagName == rb_intern("removed") ) {
+    return Removed;
+  } else if ( rb_idFlagName == rb_intern("renamed") ) {
+    return Renamed;
+  } else if ( rb_idFlagName == rb_intern("owner_modified") ) {
+    return OwnerModified;
+  } else if ( rb_idFlagName == rb_intern("attribute_modified") ) {
+    return AttributeModified;
+  } else if ( rb_idFlagName == rb_intern("moved_from") ) {
+    return MovedFrom;
+  } else if ( rb_idFlagName == rb_intern("moved_to") ) {
+    return MovedTo;
+  } else if ( rb_idFlagName == rb_intern("is_file") ) {
+    return IsFile;
+  } else if ( rb_idFlagName == rb_intern("is_dir") ) {
+    return IsDir;
+  } else if ( rb_idFlagName == rb_intern("is_symlink") ) {
+    return IsSymLink;
+  } else if ( rb_idFlagName == rb_intern("link") ) {
+    return Link;
+  } else if ( rb_idFlagName == rb_intern("overflow") ) {
+    return Overflow;
+  }
+
+  VALUE rb_str = rb_sym2str(rb_flag);
+
+  rb_raise(rb_eRuntimeError, "Unknown event type '%s'", StringValueCStr(rb_str));
+
+  return NoOp;
+}
+
+enum fsw_monitor_type fswatch_monitor_type_by(VALUE name) {
+  if (name == Qnil) {
+    return system_default_monitor_type;
+  }
+
+  VALUE rb_str = StringValue(name);
+
+  if (rb_str_equal(rb_str, rb_str_new_literal("fsevents"))) {
+    return fsevents_monitor_type;
+  } else if (rb_str_equal(rb_str, rb_str_new_literal("kqueue"))) {
+    return kqueue_monitor_type;
+  } else if (rb_str_equal(rb_str, rb_str_new_literal("inotify"))) {
+    return inotify_monitor_type;
+  } else if (rb_str_equal(rb_str, rb_str_new_literal("windows"))) {
+    return windows_monitor_type;
+  } else if (rb_str_equal(rb_str, rb_str_new_literal("poll"))) {
+    return poll_monitor_type;
+  } else if (rb_str_equal(rb_str, rb_str_new_literal("fen"))) {
+    return fen_monitor_type;
+  }
+
+  rb_raise(rb_eRuntimeError, "Unknown monitor type '%s'", StringValueCStr(rb_str));
+
+  return Qnil;
+}

data/ext/fswatch/extconf.rb

@@ -0,0 +1,33 @@
+require 'mkmf'
+
+$CXXFLAGS += " -std=c++11 "
+
+HEADER_DIRS = [
+  '/opt/local/include',
+  '/usr/local/include',
+  '/usr/include',
+].select { |d| Dir.exists?(d) }
+
+LIB_DIRS = [
+  '/opt/local/lib',
+  '/usr/local/lib',
+  '/usr/lib',
+].select { |d| Dir.exists?(d) }
+
+$srcs = Dir.glob(File.join(File.expand_path('..', __FILE__), '*.c'))
+
+dir_config('fswatch', HEADER_DIRS, LIB_DIRS)
+
+unless find_header('libfswatch/c/libfswatch.h')
+  abort "libfswatch is missing.  please install libfswatch"
+end
+
+unless find_library('fswatch', 'fsw_init_library')
+  abort "libfswatch is missing.  please install libfswatch"
+end
+
+unless have_func('fsw_is_running')
+  abort 'libfswatch version >= 1.11.3 is required. Please upgrade!'
+end
+
+create_makefile('fswatch/fswatch')

data/ext/fswatch/fswatch.c

@@ -0,0 +1,10 @@
+#include <stdint.h>
+
+#include "fswatch.h"
+
+void Init_fswatch() {
+
+  FSW_STATUS error = fsw_init_library();
+
+  init_fswatch_monitor();
+}

data/ext/fswatch/fswatch.h

@@ -0,0 +1,34 @@
+#ifndef FSWATCH_H
+#define FSWATCH_H
+
+#include <ruby.h>
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+
+#include <libfswatch/c/libfswatch.h>
+
+typedef struct FSW_EVENT_CONTEXT {
+  const fsw_cevent *const events;
+  unsigned int event_num;
+  VALUE object;
+} FSW_EVENT_CONTEXT;
+
+/* Configuration */
+extern void fswatch_configure(FSW_HANDLE handle, VALUE rb_settings);
+
+/* Callbacks */
+extern void* fswatch_start_monitor_no_gvl(void* data);
+extern void* fswatch_callback_handler_with_gvl(void* data);
+extern void fswatch_callback_handler_no_gvl(fsw_cevent const *const events, const unsigned int event_num, void *data);
+extern void fswatch_interrupt_monitor_no_gvl(void* data);
+
+/* Enum functions */
+extern VALUE fswatch_event_name(enum fsw_event_flag flag);
+extern enum fsw_monitor_type fswatch_monitor_type_by(VALUE name);
+extern enum fsw_event_flag fswatch_event_type(VALUE rb_flag);
+
+/* Monitor Class */
+extern VALUE init_fswatch_monitor();
+
+#endif /* FSWATCH_H */

data/ext/fswatch/monitor.c

@@ -0,0 +1,113 @@
+#include "fswatch.h"
+
+static VALUE fswatch_monitor_init(VALUE self, VALUE rb_settings) {
+  FSW_HANDLE *handle;
+  Data_Get_Struct(self, FSW_HANDLE, handle);
+
+  Check_Type(rb_settings, T_HASH);
+
+  VALUE rb_system_monitor = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("monitor_type")));
+
+  enum fsw_monitor_type monitor_type = fswatch_monitor_type_by(rb_system_monitor);
+
+  *handle = fsw_init_session(monitor_type);
+
+  VALUE rb_callback = rb_hash_lookup(rb_settings, ID2SYM(rb_intern("callback")));
+
+  if(rb_obj_is_proc(rb_callback) != Qtrue &&
+     rb_obj_is_method(rb_callback) != Qtrue) {
+    rb_raise(rb_eArgError, "Callback is not specified!");
+    return self;
+  }
+
+  // Saving callback to instance variable to prevent callback being garbage-collected
+  rb_ivar_set(self, rb_intern("callback"), rb_callback);
+
+  fsw_set_callback(*handle, fswatch_callback_handler_no_gvl, (void*)self);
+
+  fswatch_configure(*handle, rb_settings);
+
+  return self;
+}
+
+static VALUE fswatch_monitor_start(VALUE self) {
+  FSW_HANDLE *handle;
+  Data_Get_Struct(self, FSW_HANDLE, handle);
+
+  // fswatch spend most of the time doing nothing
+  // so its good idea to remove GIL during wait phase
+  // only to temporarily reaquire it for calling ruby callbacks
+  FSW_STATUS status = (FSW_STATUS)(intptr_t)
+    rb_thread_call_without_gvl(
+      fswatch_start_monitor_no_gvl, (void*)(*handle),
+      fswatch_interrupt_monitor_no_gvl, (void*)(*handle)
+    );
+
+  if (status != FSW_OK) {
+    rb_raise(rb_eRuntimeError, "Failed to start monitor - err: %d", status);
+  }
+
+  return Qtrue;
+}
+
+static VALUE fswatch_monitor_stop(VALUE self) {
+  FSW_HANDLE *handle;
+  Data_Get_Struct(self, FSW_HANDLE, handle);
+
+  FSW_STATUS status = fsw_stop_monitor(*handle);
+  if (status != FSW_OK) {
+    rb_raise(rb_eRuntimeError, "Failed to stop monitor - err: %d", status);
+  }
+
+  return Qtrue;
+}
+
+static VALUE fswatch_monitor_is_running(VALUE self) {
+  FSW_HANDLE *handle;
+  Data_Get_Struct(self, FSW_HANDLE, handle);
+
+  return fsw_is_running(*handle) ? Qtrue : Qfalse;
+}
+
+static void fswatch_monitor_free(void *ptr) {
+  FSW_HANDLE handle = *(FSW_HANDLE*)ptr;
+
+  if (handle) {
+    FSW_STATUS status = fsw_destroy_session(handle);
+
+    if (status == FSW_ERR_MONITOR_ALREADY_RUNNING) { 
+      fsw_stop_monitor(handle);
+      fsw_destroy_session(handle); // try to destroy monitor in a blind fate
+    } else if (status != FSW_OK) {
+      rb_warn("Failed to destroy fswatch session - err:%d", status);
+    }
+  }
+
+  ruby_xfree(ptr); // free allocated memory for pointer
+}
+
+
+static VALUE fswatch_monitor_alloc(VALUE klass) {
+  FSW_HANDLE *handle = ruby_xmalloc(sizeof(FSW_HANDLE));
+
+  *handle = NULL; // IMPORTANT! Initialize handler with NULL
+
+  return Data_Wrap_Struct(klass, NULL, fswatch_monitor_free, handle);
+}
+
+
+extern VALUE init_fswatch_monitor() {
+  VALUE rb_mFswatch = rb_define_module("Fswatch");
+  VALUE rb_cMonitor = rb_define_class_under(rb_mFswatch, "Monitor", rb_cObject);
+
+  rb_define_alloc_func(rb_cMonitor, fswatch_monitor_alloc);
+
+  rb_define_method(rb_cMonitor, "initialize",     fswatch_monitor_init, 1);
+
+  rb_define_method(rb_cMonitor, "start",  fswatch_monitor_start, 0);
+  rb_define_method(rb_cMonitor, "stop",   fswatch_monitor_stop, 0);
+
+  rb_define_method(rb_cMonitor, "running?",  fswatch_monitor_is_running, 0);
+
+  return rb_cMonitor;
+}

data/fswatch-rb.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "fswatch-rb"
+  spec.version       = '0.1.1'
+  spec.authors       = ['Igor Yamolov']
+  spec.email         = %w(clouster@yandex.ru)
+
+  spec.summary       = %q{Ruby binding for libfswatch library}
+  spec.description   = %q{Ruby library to watch filesystem changes}
+  spec.homepage      = "https://github.com/t3hk0d3/fswatch-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = %w[ext/fswatch/extconf.rb]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rake-compiler', '~> 1.0'
+  spec.add_development_dependency "rspec", "~> 3.7"
+end

data/lib/fswatch.rb

@@ -0,0 +1,10 @@
+module Fswatch
+
+	require 'fswatch/monitor' # stub for Monitor class
+  
+	require 'fswatch/fswatch' # load C-extension
+
+  require 'fswatch/watcher' # syntax-sugar
+
+end
+

data/lib/fswatch/monitor.rb

@@ -0,0 +1,21 @@
+module Fswatch
+  class Monitor
+    def initialize(options = {})
+      # stub method
+      # actual implementation is located in C extension - `ext/fswatch/monitor.c`
+      raise NotImplementedError, "Called stub method. Looks like C Extension failed to load"
+    end
+
+    def start
+      # stub method
+      # actual implementation is located in C extension - `ext/fswatch/monitor.c`
+      raise NotImplementedError, "Called stub method. Looks like C Extension failed to load"
+    end
+
+    def stop
+      # stub method
+      # actual implementation is located in C extension - `ext/fswatch/monitor.c`
+      raise NotImplementedError, "Called stub method. Looks like C Extension failed to load"
+    end
+  end
+end

data/lib/fswatch/watcher.rb

@@ -0,0 +1,59 @@
+module Fswatch
+  class Watcher
+
+    def initialize(options = {})
+      @event_handlers = []
+
+      options[:callback] = self.method(:_event_handler)
+
+      @monitor = Fswatch::Monitor.new(options)
+    end
+
+    def watch(options = {}, &block)
+      raise 'Invalid handler' unless block
+
+      options = nil if options.empty? # reduce memory usage
+
+      @event_handlers << [block, options]
+
+      return nil
+    end
+
+    def start!
+      raise 'Already running!' if running?
+
+      @thread = Thread.new { @monitor.start }
+    end
+
+    def stop!
+      raise 'Not running!' if running?
+
+      @monitor.stop
+    end
+
+    def running?
+      @monitor.running?
+    end
+
+    private
+
+    def _event_handler(events)
+      events.each do |event|
+        filename, timestamp, *event_flags = event
+
+        @event_handlers.each do |handler, options|
+          if options
+            # match filename
+            next if options[:match] && !options[:match].match?(filename)
+
+            # event
+            next if options[:on] && (options[:on] & event_flags).empty?
+          end
+
+          handler.call(filename, timestamp, event_flags, options)
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: fswatch-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Igor Yamolov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: Ruby library to watch filesystem changes
+email:
+- clouster@yandex.ru
+executables: []
+extensions:
+- ext/fswatch/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/fswatch/Makefile
+- ext/fswatch/callback.c
+- ext/fswatch/configure.c
+- ext/fswatch/enums.c
+- ext/fswatch/extconf.rb
+- ext/fswatch/fswatch.c
+- ext/fswatch/fswatch.h
+- ext/fswatch/monitor.c
+- fswatch-rb.gemspec
+- lib/fswatch.rb
+- lib/fswatch/monitor.rb
+- lib/fswatch/watcher.rb
+homepage: https://github.com/t3hk0d3/fswatch-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Ruby binding for libfswatch library
+test_files: []