ph7 · tmm1 · Dec 8, 2012
diff --git a/ext/system_timer/system_timer_native.c b/ext/system_timer/system_timer_native.c
@@ -1,9 +1,9 @@
 /*
  * SystemTimer native implementation relying on ITIMER_REAL
- * 
+ *
  * Copyright 2008 David Vollbracht & Philippe Hanrigou
  */
- 
+
 #include "ruby.h"
 #include "rubysig.h"
 #include <signal.h>
@@ -55,7 +55,7 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL
     }
     clear_pending_sigalrm_for_ruby_threads();
     log_debug("[install_first_timer] Successfully blocked SIG_ALRM at O.S. level\n");
-	
+
    /*
     * Save previous signal handler.
     */
@@ -67,15 +67,15 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL
         return Qnil;
     }
     log_debug("[install_first_timer] Successfully saved existing SIG_ALRM handler\n");
-    
-	 /*
-	  * Install Ruby Level SIG_ALRM handler
-	  */
+
+    /*
+     * Install Ruby Level SIG_ALRM handler
+     */
     install_ruby_sigalrm_handler(self);
 
     /*
-     * Save original real time interval timer and aet new real time interval timer.     
-     */	
+     * Save original real time interval timer and aet new real time interval timer.
+     */
     set_itimerval(&original_timer_interval, 0.0);
     set_itimerval_with_minimum_1s_interval(&timer_interval, seconds);
     if (0 != setitimer(ITIMER_REAL, &timer_interval, &original_timer_interval)) {
@@ -96,7 +96,7 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL
         log_error("[install_first_timer] Could not unblock SIG_ALRM, timeout will not work", DISPLAY_ERRNO);
         restore_original_timer_interval();
         restore_original_ruby_sigalrm_handler(self);
-        restore_original_sigalrm_mask_when_blocked();		
+        restore_original_sigalrm_mask_when_blocked();
     }
     log_debug("[install_first_timer] Successfully unblocked SIG_ALRM.\n");
 
@@ -121,18 +121,18 @@ static VALUE install_next_timer(VALUE self, VALUE seconds)
     }
     clear_pending_sigalrm_for_ruby_threads();
     log_debug("[install_next_timer] Successfully blocked SIG_ALRM at O.S. level\n");
-	
+
     /*
      * Set new real time interval timer.
-     */	
+     */
     set_itimerval_with_minimum_1s_interval(&timer_interval, seconds);
     if (0 != setitimer(ITIMER_REAL, &timer_interval, NULL)) {
         log_error("[install_next_timer] Could not install our own timer, timeout will not work", DISPLAY_ERRNO);
         restore_sigalrm_mask(&previous_sigalarm_mask);
         return Qnil;
     }
     if (debug_enabled) {
-      log_debug("[install_next_timer] Successfully installed timer (%ds + %dus)\n", 
+      log_debug("[install_next_timer] Successfully installed timer (%ds + %dus)\n",
                 timer_interval.it_value.tv_sec, timer_interval.it_value.tv_usec);
     }
 
@@ -163,7 +163,7 @@ static VALUE restore_original_configuration(VALUE self)
     * Install Ruby Level SIG_ALRM handler
     */
     restore_original_ruby_sigalrm_handler(self);
-	
+
     if (original_signal_handler.sa_handler == NULL) {
         log_error("[restore_original_configuration] Previous SIG_ALRM handler not initialized!", DO_NOT_DISPLAY_ERRNO);
     } else if (0 == sigaction(SIGALRM, &original_signal_handler, NULL)) {
@@ -172,9 +172,9 @@ static VALUE restore_original_configuration(VALUE self)
         log_error("[restore_original_configuration] Could not restore previous handler for SIG_ALRM", DISPLAY_ERRNO);
     }
     original_signal_handler.sa_handler = NULL;
-	
+
     restore_original_timer_interval();
-    restore_original_sigalrm_mask_when_blocked();	
+    restore_original_sigalrm_mask_when_blocked();
 }
 
 /*
@@ -199,7 +199,7 @@ static void restore_sigalrm_mask(sigset_t *previous_mask)
         log_debug("[restore_sigalrm_mask] Unblocked SIG_ALRM\n");
     } else {
         log_debug("[restore_sigalrm_mask] No Need to unblock SIG_ALRM\n");
-    }	
+    }
 }
 
 static void restore_original_sigalrm_mask_when_blocked() 
@@ -231,19 +231,19 @@ static VALUE enable_debug(VALUE self) {
 
 static VALUE disable_debug(VALUE self) {
     debug_enabled = 0;
-    return Qnil;	
+    return Qnil;
 }
 
-static void log_debug(char* message, ...) 
+static void log_debug(char* message, ...)
 {
     va_list argp;
-    
-	  if (0 != debug_enabled) {
-	      va_start(argp, message);
+
+    if (0 != debug_enabled) {
+      va_start(argp, message);
         vfprintf(stdout, message, argp);
         va_end(argp);
     }
-	  return;
+    return;
 }
 
 static void log_error(char* message, int display_errno)
@@ -277,7 +277,7 @@ static void set_itimerval_with_minimum_1s_interval(struct itimerval *value,
                                                    VALUE seconds) {
 
     double sanitized_second_interval;
-                                                     
+
     sanitized_second_interval = NUM2DBL(seconds) + MINIMUM_TIMER_INTERVAL_IN_SECONDS;
     if (sanitized_second_interval < MINIMUM_TIMER_INTERVAL_IN_SECONDS ) {
         sanitized_second_interval = MINIMUM_TIMER_INTERVAL_IN_SECONDS;
@@ -295,14 +295,14 @@ static void set_itimerval(struct itimerval *value, double seconds) {
     value->it_value.tv_usec = (long int) ((seconds - value->it_value.tv_sec) \
                                           * MICRO_SECONDS);
     if (debug_enabled) {
-      log_debug("[set_itimerval] Set to %ds + %dus\n", value->it_value.tv_sec, 
+      log_debug("[set_itimerval] Set to %ds + %dus\n", value->it_value.tv_sec,
                                                        value->it_value.tv_usec);
     }
     return;
 }
 
 
-void Init_system_timer_native() 
+void Init_system_timer_native()
 {
     init_sigalarm_mask();
     rb_cSystemTimer = rb_define_module("SystemTimer");

diff --git a/lib/system_timer/concurrent_timer_pool.rb b/lib/system_timer/concurrent_timer_pool.rb
@@ -1,13 +1,13 @@
 # Copyright 2008 David Vollbracht & Philippe Hanrigou
 
 module SystemTimer
-  
+
   class ConcurrentTimerPool
-    
+
     def registered_timers
       @timers ||= []
     end
-        
+
     def register_timer(trigger_time, thread, exception_class=nil)
       new_timer = ThreadTimer.new(trigger_time, thread, exception_class)
       registered_timers << new_timer
@@ -19,15 +19,15 @@ def add_timer(interval_in_seconds, exception_class=nil)
       log_registered_timers if SystemTimer.debug_enabled?
       new_timer
     end
-    
+
     def cancel(registered_timer)
       registered_timers.delete registered_timer
     end
-    
+
     def first_timer?
       registered_timers.size == 1
     end
-    
+
     def next_timer
       registered_timers.sort {|x,y| x.trigger_time <=> y.trigger_time}.first
     end
@@ -41,14 +41,14 @@ def next_trigger_interval_in_seconds
       timer = next_timer
       [0, (timer.trigger_time - Time.now.to_f)].max unless timer.nil?
     end
-    
+
     def next_expired_timer(now_in_seconds_since_epoch)
       candidate_timer = next_timer
       if SystemTimer.debug_enabled?
         puts "Candidate timer at #{now_in_seconds_since_epoch} : " +
              candidate_timer.inspect
       end
-      return nil if candidate_timer.nil? || 
+      return nil if candidate_timer.nil? ||
                     candidate_timer.trigger_time > now_in_seconds_since_epoch
       candidate_timer
     end
@@ -67,7 +67,7 @@ def trigger_next_expired_timer
       puts "Trigger next expired timer" if SystemTimer.debug_enabled?
       trigger_next_expired_timer_at Time.now.to_f
     end
-    
+
     def log_timeout_received(thread_timer)          #:nodoc:
       puts <<-EOS
         ==== Triger Timer ==== #{thread_timer}
@@ -83,7 +83,7 @@ def log_registered_timers          #:nodoc:
             Registered Timers: #{registered_timers.map {|t| t.to_s}.join("\n                               ")}
       EOS
     end
-    
+
   end
-  
+
 end
diff --git a/lib/system_timer/thread_timer.rb b/lib/system_timer/thread_timer.rb
@@ -2,21 +2,21 @@
 
 module SystemTimer
 
-  # Timer saving associated thread. This is needed because we trigger timers 
-  # from a Ruby signal handler and Ruby signals are always delivered to 
+  # Timer saving associated thread. This is needed because we trigger timers
+  # from a Ruby signal handler and Ruby signals are always delivered to
   # main thread.
   class ThreadTimer
     attr_reader :trigger_time, :thread, :exception_class
-    
+
     def initialize(trigger_time, thread, exception_class = nil)
       @trigger_time = trigger_time
       @thread = thread
-	  @exception_class = exception_class || Timeout::Error
+      @exception_class = exception_class || Timeout::Error
     end
-    
+
     def to_s
       "<ThreadTimer :time => #{trigger_time}, :thread => #{thread}, :exception_class => #{exception_class}>"
     end
-    
+
   end
 end
diff --git a/lib/system_timer_stub.rb b/lib/system_timer_stub.rb
@@ -2,7 +2,7 @@
 
 require 'timeout'
 
-module SystemTimer 
+module SystemTimer
  class << self
 
    def timeout_after(seconds)
@@ -12,8 +12,8 @@ def timeout_after(seconds)
    end
 
    # Backward compatibility with timeout.rb
-   alias timeout timeout_after 
-   
+   alias timeout timeout_after
+
  end
- 
+
 end