supplement 1.6

data/lib/supplement/filesys.h

@@ -0,0 +1,35 @@
+/*
+ *  supplement/filesys.h  --  File system tools
+ */
+
+#ifndef __SUPPLEMENT_FILESYS_H__
+#define __SUPPLEMENT_FILESYS_H__
+
+#include <ruby.h>
+
+
+extern VALUE rb_fsstat_s_alloc( VALUE);
+extern VALUE rb_fsstat_init( VALUE, VALUE);
+extern VALUE rb_fsstat_init_copy( VALUE, VALUE);
+
+extern VALUE rb_fsstat_type(   VALUE);
+extern VALUE rb_fsstat_bsize(  VALUE);
+extern VALUE rb_fsstat_blocks( VALUE);
+extern VALUE rb_fsstat_bfree(  VALUE);
+extern VALUE rb_fsstat_bavail( VALUE);
+extern VALUE rb_fsstat_files(  VALUE);
+extern VALUE rb_fsstat_ffree(  VALUE);
+extern VALUE rb_fsstat_fsid(   VALUE);
+
+extern VALUE rb_fsstat_bytes(  VALUE);
+extern VALUE rb_fsstat_free(   VALUE);
+extern VALUE rb_fsstat_avail(  VALUE);
+extern VALUE rb_fsstat_pfree(  VALUE);
+extern VALUE rb_fsstat_pavail( VALUE);
+
+extern VALUE rb_fsstat_inspect( VALUE);
+
+extern void Init_filesys( void);
+
+#endif
+

data/lib/supplement/itimer.c

@@ -0,0 +1,126 @@
+/*
+ *  supplement/itimer.c  --  Interval timer
+ */
+
+
+#include "itimer.h"
+
+#include <math.h>
+
+static void  suppelement_sec_timeval( VALUE, struct timeval *t);
+static VALUE suppelement_timeval_sec( struct timeval *);
+
+
+/*
+ *  call-seq:
+ *     Process.setitimer( interval = nil, value = nil)   -> nil
+ *
+ *  Set alarm timer. If <code>value</code> is nonzero, it is the
+ *  expiration time to the first alarm. If it is zero, the timer is disabled.
+ *  If <code>value</code> is nonzero and <code>interval</code> is zero,
+ *  the alarm is triggered once.
+ *
+ */
+
+VALUE
+rb_process_setitimer( int argc, VALUE *argv, VALUE obj)
+{
+    VALUE isec;
+    VALUE vsec;
+    struct itimerval it;
+
+    rb_scan_args( argc, argv, "02", &isec, &vsec);
+
+    suppelement_sec_timeval( isec, &it.it_interval);
+    if (NIL_P(vsec) && !NIL_P(isec))
+        it.it_value = it.it_interval;
+    else
+    suppelement_sec_timeval( vsec, &it.it_value);
+
+    if (setitimer( ITIMER_REAL, &it, NULL) < 0)
+        rb_raise( rb_eSystemCallError, "setitimer failed.");
+    return Qnil;
+}
+
+void
+suppelement_sec_timeval( VALUE secs, struct timeval *t)
+{
+    switch (TYPE(secs)) {
+      case T_FIXNUM:
+        t->tv_sec = FIX2LONG(secs), t->tv_usec = 0;
+        if (t->tv_sec < 0)
+            rb_raise( rb_eArgError, "time interval must be positive");
+        break;
+
+      case T_FLOAT:
+        if (RFLOAT_VALUE(secs) < 0.0)
+            rb_raise( rb_eArgError, "time interval must be positive");
+        else {
+            double f, d;
+
+            d = modf( RFLOAT_VALUE(secs), &f);
+            t->tv_sec = (time_t) f, t->tv_usec = (time_t) (d*1e6+0.5);
+            if (f != t->tv_sec)
+                rb_raise( rb_eRangeError, "time interval out of Time range",
+                    RFLOAT_VALUE(secs));
+        }
+        break;
+
+      case T_BIGNUM:
+        t->tv_sec = NUM2LONG(secs), t->tv_usec = 0;
+        if (t->tv_sec < 0)
+            rb_raise(rb_eArgError, "time interval must be positive");
+        break;
+
+      case T_NIL:
+        t->tv_sec = 0, t->tv_usec = 0;
+        break;
+
+      default:
+        rb_raise( rb_eTypeError, "can't convert %s into time interval",
+                 rb_obj_classname( secs));
+        break;
+    }
+}
+
+
+/*
+ *  call-seq:
+ *     Process.getitimer -> [interval, value]
+ *
+ *  Returns the interval and the remaining seconds to next alarm.
+ */
+
+VALUE
+rb_process_getitimer( VALUE obj)
+{
+    struct itimerval it;
+    VALUE r;
+
+    if (getitimer( ITIMER_REAL, &it) < 0)
+        rb_raise( rb_eSystemCallError, "getitimer failed.");
+
+    r = rb_ary_new3( 2,
+      suppelement_timeval_sec( &it.it_interval),
+      suppelement_timeval_sec( &it.it_value));
+    return r;
+}
+
+VALUE
+suppelement_timeval_sec( struct timeval *t)
+{
+    VALUE r;
+    if (t->tv_usec)
+        r = rb_float_new( t->tv_sec + (1e-6 * t->tv_usec));
+    else
+        r = INT2NUM(t->tv_sec);
+    return r;
+}
+
+
+void Init_itimer( void)
+{
+    rb_define_singleton_method( rb_mProcess, "setitimer", rb_process_setitimer, -1);
+    rb_define_singleton_method( rb_mProcess, "getitimer", rb_process_getitimer, 0);
+}
+

data/lib/supplement/itimer.h

@@ -0,0 +1,17 @@
+/*
+ *  supplement/itimer.h  --  Interval timer
+ */
+
+#ifndef __SUPPLEMENT_ITIMER_H__
+#define __SUPPLEMENT_ITIMER_H__
+
+#include <ruby.h>
+
+
+extern VALUE rb_process_setitimer( int, VALUE *, VALUE);
+extern VALUE rb_process_getitimer( VALUE obj);
+
+extern void Init_itimer( void);
+
+#endif
+

data/lib/supplement/terminal.c

@@ -0,0 +1,144 @@
+/*
+ *  supplement/terminal.c  --  Terminal methods
+ */
+
+#include "terminal.h"
+
+#if   HAVE_HEADER_RUBYIO_H
+    #include <rubyio.h>
+#elif HAVE_HEADER_RUBY_IO_H
+    #include <ruby/io.h>
+#endif
+
+#include <sys/ioctl.h>
+#include <termios.h>
+
+static VALUE io_unget( VALUE);
+static VALUE io_reset( VALUE);
+
+
+#ifndef RUBY_VM
+  #define RB_SYS_FAIL( fptr)     rb_sys_fail( ((OpenFile *) fptr)->path);
+#else
+  #define RB_SYS_FAIL( fptr)     rb_sys_fail_str( ((rb_io_t *) fptr)->pathv);
+#endif
+
+/*
+ *  call-seq:
+ *     io.unget(str, ...)   -> nil
+ *
+ *  Feed <em>str</em> into the TTY's input queue.
+ *
+ *     $stdin.unget "hello\n"    #=> nil
+ */
+
+VALUE
+rb_io_unget( int argc, VALUE *argv, VALUE io)
+{
+#ifndef RUBY_VM
+    OpenFile *fptr;
+#else
+    rb_io_t *fptr;
+#endif
+    int fd;
+    struct termios oldtio, newtio;
+    void *v[5];
+
+    GetOpenFile( io, fptr);
+#ifndef RUBY_VM
+    fd = fileno( fptr->f);
+#else
+    fd = fptr->fd;
+#endif
+
+    if (tcgetattr( fd, &oldtio) < 0)
+        RB_SYS_FAIL( fptr);
+    newtio = oldtio;
+    newtio.c_iflag &= ~ICRNL;
+    if (tcsetattr( fd, TCSANOW, &newtio) < 0)
+        RB_SYS_FAIL( fptr);
+
+    v[0] = &fd, v[1] = fptr, v[2] = &oldtio,
+        v[3] = &argc, v[4] = (void *) argv;
+    return rb_ensure( io_unget, (VALUE) v, io_reset, (VALUE) v);
+}
+
+VALUE
+io_unget( VALUE v)
+{
+    void **vp = (void **) v;
+    VALUE str;
+    long i;
+    int j;
+    char *p;
+    int *argc;
+    VALUE *argv;
+
+    argc = (int *)vp[3], argv = (VALUE *) vp[4];
+    for (j = 0 ; j < *argc; ++j) {
+        str = argv[ j];
+        p = RSTRING_PTR(str);
+        for (i = RSTRING_LEN(str); i; --i, ++p)
+            if (ioctl( *(int *) vp[0], TIOCSTI, p) < 0)
+                RB_SYS_FAIL( vp[1]);
+    }
+    return Qnil;
+}
+
+VALUE
+io_reset( VALUE v)
+{
+    void **vp = (void **) v;
+
+    if (tcsetattr( *(int *) vp[0], TCSANOW, (struct termios *) vp[2]) < 0)
+        RB_SYS_FAIL( vp[1]);
+
+    return Qnil;
+}
+
+
+/*
+ *  call-seq:
+ *     io.winsize()   -> ary
+ *
+ *  Get the available window space.
+ *
+ *     cols, rows, xpixel, ypixel = $stdout.winsize
+ */
+
+VALUE
+rb_io_winsize( VALUE self)
+{
+#ifndef RUBY_VM
+    OpenFile *fptr;
+#else
+    rb_io_t *fptr;
+#endif
+    int fd;
+    struct winsize w;
+    VALUE r;
+
+    GetOpenFile( self, fptr);
+#ifndef RUBY_VM
+    fd = fileno( fptr->f);
+#else
+    fd = fptr->fd;
+#endif
+
+    if (ioctl( fd, TIOCGWINSZ, &w) < 0)
+        RB_SYS_FAIL( fptr);
+    r = rb_ary_new2( 4);
+    rb_ary_store( r, 0, INT2NUM( w.ws_col));
+    rb_ary_store( r, 1, INT2NUM( w.ws_row));
+    rb_ary_store( r, 2, INT2NUM( w.ws_xpixel));
+    rb_ary_store( r, 3, INT2NUM( w.ws_ypixel));
+    return r;
+}
+
+
+void Init_terminal( void)
+{
+    rb_define_method( rb_cIO, "unget", rb_io_unget, -1);
+    rb_define_method( rb_cIO, "winsize", rb_io_winsize, 0);
+}
+

data/lib/supplement/terminal.h

@@ -0,0 +1,21 @@
+/*
+ *  supplement/terminal.h  --  Terminal methods
+ */
+
+#ifndef __SUPPLEMENT_TERMINAL_H__
+#define __SUPPLEMENT_TERMINAL_H__
+
+#if   HAVE_HEADER_RUBY_H
+    #include <ruby.h>
+#elif HAVE_HEADER_RUBY_RUBY_H
+    #include <ruby/ruby.h>
+#endif
+
+
+extern VALUE rb_io_unget( int, VALUE *, VALUE);
+extern VALUE rb_io_winsize( VALUE);
+
+extern void Init_terminal( void);
+
+#endif
+

data/lib/sync.c

@@ -0,0 +1,34 @@
+/*
+ *  sync.c  --  Sync all
+ */
+
+
+#include "sync.h"
+
+#include <ruby.h>
+#include <unistd.h>
+
+
+static VALUE rb_process_sync( VALUE obj);
+
+
+/*
+ *  call-seq:
+ *     Process.sync -> nil
+ *
+ * Force completion of pending disk writes (flush cache). See sync(8).
+ */
+
+VALUE
+rb_process_sync( VALUE obj)
+{
+    sync();
+    return Qnil;
+}
+
+
+void Init_supplement_sync( void)
+{
+    rb_define_singleton_method( rb_mProcess, "sync", rb_process_sync, 0);
+}
+

data/lib/sync.h

@@ -0,0 +1,13 @@
+/*
+ *  sync.h  --  Sync all
+ */
+
+
+#ifndef __SYNC_H__
+#define __SYNC_H__
+
+
+extern void Init_supplement_sync( void);
+
+#endif
+

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: supplement
+version: !ruby/object:Gem::Version
+  version: '1.6'
+platform: ruby
+authors:
+- Bertram Scharpf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: autorake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: ! 'Simple methods that didn''t manage to become part of standard Ruby.
+
+'
+email: <software@bertram-scharpf.de>
+executables: []
+extensions:
+- lib/mkrf_conf
+extra_rdoc_files:
+- README
+- LICENSE
+files:
+- lib/mkrf_conf
+- lib/Rakefile
+- lib/supplement.c
+- lib/supplement.h
+- lib/sync.c
+- lib/sync.h
+- lib/supplement/filesys.c
+- lib/supplement/filesys.h
+- lib/supplement/itimer.c
+- lib/supplement/itimer.h
+- lib/supplement/terminal.c
+- lib/supplement/terminal.h
+- lib/supplement/date.rb
+- examples/teatimer
+- README
+- LICENSE
+homepage: http://www.bertram-scharpf.de
+licenses: []
+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:
+- Ruby and the autorake gem
+rubyforge_project: NONE
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Simple Ruby extensions
+test_files: []