tidings 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbe1831ad74b02894406f9969fca0ceb6240ca90
-  data.tar.gz: 025784c85abf46654519579b0b70075c25ad6994
+  metadata.gz: acdbaca8aecfaa40103a8b5b9dbf7932322cccc0
+  data.tar.gz: 3906c9fff15182a42c9d472a69bb0190fb2b6ccf
 SHA512:
-  metadata.gz: 34d4541a3abf171a7cafee93930dd477a3341e033b1289cf51cba6500f2d1ac0c511a9c0df48788f8ce9d5ecaecf6cda613ab2aaf63743fd0495096c41fe2d67
-  data.tar.gz: df256ad3c8678154cc39a057d397740a45f9ac86283d27f454d0533d38cce2081fb40fede9ea85d543bcde4e6a33cb5de62d89357f71b1cc5975b8f9bf82819a
+  metadata.gz: 752e52830262e1f14e2fe360621ad0e7fd34fa00e31e597a3bf822559c8650b043c5d702b71a4cc080754ccdb853f3db95b1467acbe4cddc207f7fca2c3b8d72
+  data.tar.gz: 1d445b0ad98e8b663a4b96d637f66bcafad891ec1a55cbc61f723f62f08451f6dcebb491de7ed57c0c4b2191dc6dc9b0f767441c64baba0ea93608a7274db85e

data/ext/extconf.rb

@@ -3,8 +3,8 @@ require 'mkmf'
 case RUBY_PLATFORM
 when /darwin/
   with_ldflags("-framework CoreServices") do
-    create_makefile("fs_event/fs_event", "fs_event")
+    create_makefile("fs_event", "fs_event")
   end
 when /linux/
-  create_makefile("inotify/inotify", "inotify")
+  create_makefile("inotify", "inotify")
 end

data/ext/fs_event/fs_event.c

@@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <ruby.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreServices/CoreServices.h>
+
+static VALUE processor;
+
+VALUE fs_event_event_flags(const FSEventStreamEventFlags eventFlags)
+{
+  VALUE event_flags = rb_ary_new();
+
+  if (eventFlags & kFSEventStreamEventFlagMustScanSubDirs)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("must_scan")));
+  if (eventFlags & kFSEventStreamEventFlagItemCreated)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("created")));
+  if (eventFlags & kFSEventStreamEventFlagItemRemoved)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("removed")));
+  if (eventFlags & kFSEventStreamEventFlagItemRenamed)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("renamed")));
+  if (eventFlags & kFSEventStreamEventFlagItemModified)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("modified")));
+  if (eventFlags & kFSEventStreamEventFlagItemIsFile)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("file")));
+  if (eventFlags & kFSEventStreamEventFlagItemIsDir)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("dir")));
+
+  return event_flags;
+}
+
+void fs_event_callback(
+  ConstFSEventStreamRef streamRef,
+  void *userData,
+  size_t numberOfEvents,
+  void *eventPaths,
+  const FSEventStreamEventFlags eventFlags[],
+  const FSEventStreamEventId eventIds[]
+)
+{
+  char **paths = eventPaths;
+  size_t index;
+
+  for(index=0; index < numberOfEvents; index++) {
+    rb_funcall(processor, rb_intern("call"), 2,
+      rb_str_new2(paths[index]),
+      fs_event_event_flags(eventFlags[index])
+    );
+  }
+}
+
+/*
+ *  call-seq:
+ *    fs_event_watch(path, processor)
+ *
+ *  Calls the block with the changed paths when something changes in the
+ *  specified path. This method blocks the thread forever.
+ *
+ *    FSEvent.watch('/tmp', Proc.new { |files| p files })
+ */
+static VALUE fs_event_watch(VALUE self, VALUE path, VALUE proc)
+{
+  processor = proc;
+
+  CFStringRef cfPaths[1];
+  cfPaths[0] = CFStringCreateWithCString(
+    kCFAllocatorSystemDefault,
+    RSTRING_PTR(path),
+    kCFStringEncodingUTF8
+  );
+  CFArrayRef paths = CFArrayCreate(kCFAllocatorSystemDefault, (const void **)cfPaths, 1, NULL);
+
+  FSEventStreamRef streamRef = FSEventStreamCreate(
+    NULL,
+    &fs_event_callback,
+    NULL,
+    paths,
+    kFSEventStreamEventIdSinceNow,
+    (CFTimeInterval)0.5,
+    kFSEventStreamCreateFlagWatchRoot | kFSEventStreamCreateFlagFileEvents
+  );
+
+#ifdef DEBUG
+  FSEventStreamShow(streamRef);
+#endif
+
+  FSEventStreamScheduleWithRunLoop(streamRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+  FSEventStreamStart(streamRef);
+
+  CFRunLoopRun();
+
+  FSEventStreamFlushSync(streamRef);
+  FSEventStreamStop(streamRef);
+
+  return Qnil;
+}
+
+void Init_fs_event()
+{
+  VALUE mFSEvent;
+
+  mFSEvent = rb_define_module("FSEvent");
+  
+  rb_define_module_function(mFSEvent, "watch", fs_event_watch, 2);
+}

data/ext/inotify/inotify.c

@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/inotify.h>
+#include <unistd.h>
+#include <ruby.h>
+
+#define EVENT_SIZE  ( sizeof (struct inotify_event) )
+#define BUF_LEN     ( 1024 * ( EVENT_SIZE + 16 ) )
+
+VALUE inotify_event_flags(uint32_t mask)
+{
+  VALUE event_flags = rb_ary_new();
+
+  if (mask & IN_ACCESS)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("accessed")));
+  if (mask & IN_CREATE)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("created")));
+  if (mask & IN_DELETE)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("removed")));
+  if (mask & IN_MODIFY)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("modified")));
+  if (mask & IN_ISDIR)
+    rb_ary_push(event_flags, ID2SYM(rb_intern("dir")));
+  else
+    rb_ary_push(event_flags, ID2SYM(rb_intern("file")));
+
+  return event_flags;
+}
+
+/*
+ *  call-seq:
+ *    inotify_watch(path, processor)
+ *
+ *  Calls the block with the changed paths when something changes in the
+ *  specified path. This method blocks the thread forever.
+ *
+ *    Inotify.watch('/tmp', Proc.new { |files| p files })
+ */
+static VALUE inotify_watch(VALUE self, VALUE path, VALUE processor)
+{
+  int length, i;
+  int notify;
+  int watch;
+  char buffer[BUF_LEN];
+  VALUE mFile = rb_const_get(rb_cObject, rb_intern("File"));
+
+  fd_set rfds;
+  struct timeval tv;
+  int retval;
+
+  notify = inotify_init();
+
+  if (notify < 0) perror("inotify_init");
+
+  watch = inotify_add_watch(notify, RSTRING_PTR(path), IN_MODIFY | IN_CREATE | IN_DELETE );
+
+  for (;;)
+  {
+    FD_ZERO(&rfds);
+    FD_SET(notify, &rfds);
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 500;
+
+    retval = select(notify + 1, &rfds, NULL, NULL, &tv);
+
+    if (retval < 0) {
+      perror("select()");
+      return Qfalse;
+    } else if (FD_ISSET(notify, &rfds)) {
+      length = read(notify, buffer, BUF_LEN);
+      if (length < 0) perror("read");
+
+      i = 0;
+      while(i < length) {
+        struct inotify_event *event = (struct inotify_event *)&buffer[i];
+        if (event->len) {
+          rb_funcall(processor, rb_intern("call"), 2,
+            rb_funcall(mFile, rb_intern("join"), 2, path, rb_str_new2(event->name)),
+            inotify_event_flags(event->mask)
+          );
+        }
+        i += EVENT_SIZE + event->len;
+      }
+    }
+  }
+
+  inotify_rm_watch(notify, watch);
+  close(notify);
+
+  return Qnil;
+}
+
+void Init_inotify()
+{
+  VALUE mInotify;
+
+  mInotify = rb_define_module("Inotify");
+
+  rb_define_module_function(mInotify, "watch", inotify_watch, 2);
+}

data/lib/tidings/version.rb

@@ -0,0 +1,3 @@
+module Tidings
+  VERSION = '0.2.1'
+end

data/lib/tidings/watcher.rb

@@ -0,0 +1,29 @@
+module Tidings
+  class Watcher
+    def initialize(path, processor)
+      @path, @processor, @pid = path, processor, nil
+    end
+
+    def start
+      Signal.trap("SIGINT") { stop }
+      @pid = fork { watch }
+      Tidings.log("Tidings running on PID: #{@pid}")
+      Process.wait
+      Tidings.log("Tidings stopped running")
+    end
+
+    def stop
+      Process.kill("KILL", @pid)
+    end
+
+    if const_defined?(:FSEvent)
+      def watch
+        FSEvent.watch(@path, @processor)
+      end
+    elsif const_defined?(:Inotify)
+      def watch
+        Inotify.watch(@path, @processor)
+      end
+    end
+  end
+end

data/lib/tidings.rb

@@ -0,0 +1,23 @@
+case RUBY_PLATFORM
+when /darwin/
+  require 'fs_event'
+when /linux/
+  require 'inotify'
+else
+  raise RuntimeError, "Your platform is currently not supported (#{RUBY_PLATFORM})"
+end
+
+module Tidings
+  autoload :VERSION, 'tidings/version'
+  autoload :Watcher, 'tidings/watcher'
+
+  def self.log(message)
+    $stderr.puts('Tidings: ' + message.to_s) if $DEBUG
+  end
+
+  def self.watch(path, processor=nil, &block)
+    watcher = Tidings::Watcher.new(path, processor || block)
+    watcher.start
+    watcher
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tidings
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Manfred Stienstra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-01 00:00:00.000000000 Z
+date: 2013-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: peck
@@ -48,9 +48,14 @@ extra_rdoc_files:
 - README.rdoc
 - COPYING
 files:
+- lib/tidings/version.rb
+- lib/tidings/watcher.rb
+- lib/tidings.rb
+- ext/extconf.rb
+- ext/fs_event/fs_event.c
+- ext/inotify/inotify.c
 - README.rdoc
 - COPYING
-- ext/extconf.rb
 homepage: http://github.com/Manfred/tidings
 licenses: []
 metadata: {}