supplement 1.6

data/lib/supplement.h

@@ -0,0 +1,83 @@
+/*
+ *  supplement.h  --  Simple Ruby Extensions
+ */
+
+
+#ifndef __SUPPELEMENT_H__
+#define __SUPPELEMENT_H__
+
+#if   HAVE_HEADER_RUBY_H
+    #include <ruby.h>
+#elif HAVE_HEADER_RUBY_RUBY_H
+    #include <ruby/ruby.h>
+#endif
+
+
+extern VALUE rb_obj_new_string( VALUE);
+extern VALUE rb_obj_nil_if( VALUE, VALUE);
+extern VALUE rb_krn_tap( VALUE);
+extern VALUE rb_krn_tap_bang( VALUE);
+
+extern VALUE rb_nil_notempty_p( VALUE);
+extern VALUE rb_nil_each_line( VALUE);
+
+extern VALUE rb_str_new_string( VALUE);
+extern VALUE rb_str_notempty_p( VALUE);
+extern VALUE rb_str_eat( int, VALUE *, VALUE);
+extern VALUE rb_str_cut_bang( VALUE, VALUE);
+#ifdef FEATURE_STRING_CLEAR
+extern VALUE rb_str_clear( VALUE);
+#endif
+extern VALUE rb_str_head( int, VALUE *, VALUE);
+extern VALUE rb_str_rest( int, VALUE *, VALUE);
+extern VALUE rb_str_tail( int, VALUE *, VALUE);
+#ifdef FEATURE_STRING_START_WITH
+extern VALUE rb_str_start_with_p( VALUE, VALUE);
+extern VALUE rb_str_end_with_p( VALUE, VALUE);
+#endif
+extern VALUE rb_str_starts_with_p( VALUE, VALUE);
+extern VALUE rb_str_ends_with_p( VALUE, VALUE);
+#ifdef FEATURE_STRING_ORD
+extern VALUE rb_str_ord( VALUE);
+#endif
+extern VALUE rb_str_axe( int, VALUE *, VALUE);
+
+extern VALUE rb_ary_notempty_p( VALUE);
+extern VALUE rb_ary_indexes( VALUE);
+extern VALUE rb_ary_pick( VALUE);
+extern VALUE rb_ary_rpick( VALUE);
+#ifdef FEATURE_ARRAY_INDEX_WITH_BLOCK
+extern VALUE rb_ary_index( int, VALUE *, VALUE);
+extern VALUE rb_ary_rindex( int, VALUE *, VALUE);
+#endif
+#ifdef FEATURE_ARRAY_SELECT_BANG
+extern VALUE rb_ary_select_bang( VALUE);
+#endif
+
+extern VALUE rb_num_pos_p( VALUE);
+extern VALUE rb_num_neg_p( VALUE);
+extern VALUE rb_num_grammatical( VALUE, VALUE, VALUE);
+extern VALUE rb_num_sqrt( VALUE);
+extern VALUE rb_num_cbrt( VALUE);
+
+extern VALUE rb_hash_notempty_p( VALUE);
+
+extern VALUE rb_file_size( VALUE);
+extern VALUE rb_file_flockb( int, VALUE *, VALUE);
+extern VALUE rb_file_s_umask( int, VALUE *);
+extern VALUE rb_dir_s_current( VALUE);
+extern VALUE rb_dir_s_mkdir_bang( int, VALUE *);
+extern VALUE rb_dir_entries_bang( VALUE);
+extern VALUE rb_dir_chdir( VALUE);
+
+extern VALUE rb_match_begin( int, VALUE *, VALUE);
+extern VALUE rb_match_end( int, VALUE *, VALUE);
+
+#ifdef FEATURE_THREAD_EXCLUSIVE
+extern VALUE rb_thread_exclusive( void);
+#endif
+
+extern void Init_supplement( void);
+
+#endif
+

data/lib/supplement/date.rb

@@ -0,0 +1,53 @@
+#
+#  supplement/date.rb  --  More Date methods
+#
+
+require "date"
+
+class Date
+
+  def y ; year  ; end
+  def m ; month ; end
+  def d ; day   ; end
+
+  def to_a ; [ year, month, day ] ; end
+
+end
+
+unless DateTime.method_defined? :to_time then
+
+  class Time
+    def to_time ; self ; end
+    def to_date
+      jd = Date.civil_to_jd year, mon, mday, Date::ITALY
+      hd = Date.jd_to_ajd jd, 0, 0
+      Date.new! hd, 0, Date::ITALY
+    end
+    def to_datetime
+      jd = DateTime.civil_to_jd year, mon, mday, DateTime::ITALY
+      fr = DateTime.time_to_day_fraction hour, min, [sec, 59].min
+      fr += (Rational usec, 86400*1000000000)
+      of = (Rational utc_offset, 86400)
+      hd = DateTime.jd_to_ajd jd, fr, of
+      DateTime.new! hd, of, DateTime::ITALY
+    end
+  end
+
+  class Date
+    def to_time     ; Time.local year, mon, mday ; end
+    def to_date     ; self ; end
+    def to_datetime ; DateTime.new! Date.jd_to_ajd(jd,0,0), @of, @sg ; end
+  end
+
+  class DateTime < Date
+    def to_time
+      (new_offset 0).instance_eval do
+        Time.utc year, mon, mday, hour, min, sec + sec_fraction
+      end.getlocal
+    end
+    def to_date     ; Date.new! Date.jd_to_ajd(jd,0,0), 0, @sg ; end
+    def to_datetime ; self ; end
+  end
+
+end
+

data/lib/supplement/filesys.c

@@ -0,0 +1,395 @@
+/*
+ *  supplement/filesys.c  --  File system tools
+ */
+
+#include "filesys.h"
+
+#include <stdlib.h>
+#ifdef __FSID_T_TYPE
+    /* Linux */
+    #include <sys/vfs.h>
+#else
+    #include <sys/param.h>
+    #include <sys/mount.h>
+#endif
+
+
+
+static struct statfs *get_statfs( VALUE);
+
+static ID id_mul;
+
+/*
+ *  Document-class: Filesys
+ *
+ *  File systems. Mount and umount commands are on the TODO list.
+ */
+
+/*
+ *  Document-class: Filesys::Stat
+ *
+ *  Objects of class <code>Filesys::Stat</code> encapsulate common status
+ *  information for <code>Filesys</code> objects. The information is
+ *  recorded at the moment the <code>Filesys::Stat</code> object is
+ *  created; changes made to the file after that point will not be
+ *  reflected.
+ *
+ *  Many of its attributes contain platform-specific values, and not all
+ *  values are meaningful on all systems.
+ */
+
+VALUE
+rb_fsstat_s_alloc( VALUE klass)
+{
+    return Data_Wrap_Struct( klass, NULL, &free, (struct statfs *) NULL);
+}
+
+/*
+ * call-seq:
+ *
+ *   Filesys::Stat.new( dir_name)  => stat
+ *
+ * Create a Filesys::Stat object for the given file system.
+ */
+
+VALUE
+rb_fsstat_init( VALUE obj, VALUE dname)
+{
+    struct statfs st, *nst;
+
+    SafeStringValue( dname);
+
+    if (statfs( StringValueCStr( dname), &st) == -1)
+        rb_sys_fail( RSTRING_PTR(dname));
+    if (DATA_PTR(obj)) {
+        free( DATA_PTR(obj));
+        DATA_PTR(obj) = NULL;
+    }
+    nst = ALLOC(struct statfs);
+    *nst = st;
+    DATA_PTR(obj) = nst;
+
+    return Qnil;
+}
+
+/* :nodoc: */
+VALUE
+rb_fsstat_init_copy( VALUE copy, VALUE orig)
+{
+    struct statfs *nst;
+
+    if (copy == orig)
+        return orig;
+
+    rb_check_frozen( copy);
+    if (!rb_obj_is_instance_of( orig, rb_obj_class( copy)))
+        rb_raise(rb_eTypeError, "wrong argument class");
+    if (DATA_PTR(copy)) {
+        free( DATA_PTR(copy));
+        DATA_PTR(copy) = NULL;
+    }
+    if (DATA_PTR(orig)) {
+        nst = ALLOC(struct statfs);
+        *nst = *(struct statfs *) DATA_PTR(orig);
+        DATA_PTR(copy) = nst;
+    }
+
+    return copy;
+}
+
+/* :nodoc: */
+struct statfs *
+get_statfs( VALUE self)
+{
+    struct statfs *st;
+    Data_Get_Struct(self, struct statfs, st);
+    if (!st)
+        rb_raise( rb_eTypeError, "uninitialized Filesys::Stat");
+    return st;
+}
+
+
+
+/*
+ *  call-seq:
+ *     stat.type    => fixnum
+ *
+ *  Type of filesystem.
+ */
+
+VALUE
+rb_fsstat_type( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_type);
+}
+
+/*
+ *  call-seq:
+ *     stat.bsize    => fixnum
+ *
+ *  Filesystem fragment size.
+ */
+
+VALUE
+rb_fsstat_bsize( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_bsize);
+}
+
+/*
+ *  call-seq:
+ *     stat.blocks    => fixnum
+ *
+ *  Total data blocks in filesystem.
+ */
+
+VALUE
+rb_fsstat_blocks( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_blocks);
+}
+
+/*
+ *  call-seq:
+ *     stat.bfree    => fixnum
+ *
+ *  Free blocks in filesystem.
+ */
+
+VALUE
+rb_fsstat_bfree( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_bfree);
+}
+
+/*
+ *  call-seq:
+ *     stat.bavail    => fixnum
+ *
+ *  Free blocks avail to non-superuser.
+ */
+
+VALUE
+rb_fsstat_bavail( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_bavail);
+}
+
+/*
+ *  call-seq:
+ *     stat.files    => fixnum
+ *
+ *  Total file nodes in filesystem.
+ */
+
+VALUE
+rb_fsstat_files( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_files);
+}
+
+/*
+ *  call-seq:
+ *     stat.ffree    => fixnum
+ *
+ *  Free nodes avail to non-superuser.
+ */
+
+VALUE
+rb_fsstat_ffree( VALUE self)
+{
+    return INT2NUM(get_statfs(self)->f_ffree);
+}
+
+
+/*
+ *  call-seq:
+ *     stat.fsid    => ary
+ *
+ *  Filesystem id; array of 2 integers.
+ */
+
+#ifdef __FSID_T_TYPE
+    /* Linux */
+    #define FSID_val __val
+#else
+    #define FSID_val val
+#endif
+
+VALUE
+rb_fsstat_fsid( VALUE self)
+{
+    struct statfs *s;
+    VALUE r;
+
+    s = get_statfs( self);
+    r = rb_ary_new3( 2,
+        INT2NUM(s->f_fsid.FSID_val[0]),
+        INT2NUM(s->f_fsid.FSID_val[1]));
+    return r;
+}
+
+
+/*
+ *  call-seq:
+ *     stat.bytes    => fixnum
+ *
+ *  Total data bytes in filesystem.
+ */
+
+VALUE
+rb_fsstat_bytes( VALUE self)
+{
+    struct statfs *s;
+
+    s = get_statfs( self);
+    return rb_funcall( INT2NUM(s->f_blocks), id_mul, 1, INT2NUM(s->f_bsize));
+}
+
+/*
+ *  call-seq:
+ *     stat.free    => num
+ *
+ *  Free bytes in filesystem.
+ */
+
+VALUE
+rb_fsstat_free( VALUE self)
+{
+    struct statfs *s;
+
+    s = get_statfs( self);
+    return rb_funcall( INT2NUM(s->f_bfree), id_mul, 1, INT2NUM(s->f_bsize));
+}
+
+/*
+ *  call-seq:
+ *     stat.avail    => num
+ *
+ *  Free bytes avail to non-superuser.
+ */
+
+VALUE
+rb_fsstat_avail( VALUE self)
+{
+    struct statfs *s;
+
+    s = get_statfs( self);
+    return rb_funcall( INT2NUM(s->f_bavail), id_mul, 1, INT2NUM(s->f_bsize));
+}
+
+
+/*
+ *  call-seq:
+ *     stat.pfree    => fixnum
+ *
+ *  Free percentage in filesystem.
+ */
+
+VALUE
+rb_fsstat_pfree( VALUE self)
+{
+    struct statfs *s;
+
+    s = get_statfs( self);
+    return rb_float_new( 100.0 * s->f_bfree / s->f_blocks);
+}
+
+/*
+ *  call-seq:
+ *     stat.pavail    => fixnum
+ *
+ *  Free percentage avail to non-superuser.
+ */
+
+VALUE
+rb_fsstat_pavail( VALUE self)
+{
+    struct statfs *s;
+
+    s = get_statfs( self);
+    return rb_float_new( 100.0 * s->f_bavail / s->f_blocks);
+}
+
+
+/*
+ * call-seq:
+ *   stat.inspect  =>  string
+ *
+ * Produce a nicely formatted description of <i>stat</i> with all available
+ * information.
+ */
+
+VALUE
+rb_fsstat_inspect( VALUE self)
+{
+    VALUE str;
+    int i, m;
+    static const struct {
+        const char  *name;
+        VALUE      (*func)(VALUE);
+    } member[] = {
+        { "type",   &rb_fsstat_type  },
+        { "bsize",  &rb_fsstat_bsize },
+        { "blocks", &rb_fsstat_blocks},
+        { "bfree",  &rb_fsstat_bfree },
+        { "bavail", &rb_fsstat_bavail},
+        { "files",  &rb_fsstat_files },
+        { "ffree",  &rb_fsstat_ffree },
+        { "fsid",   &rb_fsstat_fsid  }
+    };
+
+    str = rb_str_buf_new2("#<");
+    rb_str_buf_cat2(str, rb_obj_classname( self));
+    rb_str_buf_cat2(str, " ");
+
+    m = sizeof(member) / sizeof(member[0]);
+    for (i = 0; i < m; i++) {
+        VALUE v;
+
+        if (i > 0)
+            rb_str_buf_cat2( str, ", ");
+        rb_str_buf_cat2( str, member[i].name);
+        rb_str_buf_cat2( str, "=");
+        rb_str_append( str, rb_inspect( (*member[i].func)( self)));
+    }
+    rb_str_buf_cat2( str, ">");
+    OBJ_INFECT( str, self);
+
+    return str;
+}
+
+
+
+void Init_filesys( void)
+{
+    VALUE rb_cFilesys;
+    VALUE rb_cFilesysStat;
+
+    rb_cFilesys = rb_define_class( "Filesys", rb_cObject);
+
+    rb_cFilesysStat = rb_define_class_under( rb_cFilesys, "Stat", rb_cObject);
+    rb_define_alloc_func( rb_cFilesysStat,  rb_fsstat_s_alloc);
+    rb_define_method( rb_cFilesysStat, "initialize", rb_fsstat_init, 1);
+    rb_define_method( rb_cFilesysStat, "initialize_copy", rb_fsstat_init_copy, 1);
+
+    rb_define_method( rb_cFilesysStat, "type",   rb_fsstat_type  , 0);
+    rb_define_method( rb_cFilesysStat, "bsize",  rb_fsstat_bsize , 0);
+    rb_define_method( rb_cFilesysStat, "blocks", rb_fsstat_blocks, 0);
+    rb_define_method( rb_cFilesysStat, "bfree",  rb_fsstat_bfree , 0);
+    rb_define_method( rb_cFilesysStat, "bavail", rb_fsstat_bavail, 0);
+    rb_define_method( rb_cFilesysStat, "files",  rb_fsstat_files , 0);
+    rb_define_method( rb_cFilesysStat, "ffree",  rb_fsstat_ffree , 0);
+    rb_define_method( rb_cFilesysStat, "fsid",   rb_fsstat_fsid  , 0);
+
+    rb_define_method( rb_cFilesysStat, "bytes",  rb_fsstat_bytes, 0);
+    rb_define_method( rb_cFilesysStat, "free",   rb_fsstat_free , 0);
+    rb_define_method( rb_cFilesysStat, "avail",  rb_fsstat_avail, 0);
+    rb_define_method( rb_cFilesysStat, "pfree",  rb_fsstat_pfree , 0);
+    rb_define_method( rb_cFilesysStat, "pavail", rb_fsstat_pavail, 0);
+
+    rb_define_method( rb_cFilesysStat, "inspect", rb_fsstat_inspect, 0);
+
+    id_mul = rb_intern( "*");
+}
+