sfml3-rb 0.2.2 → 0.3.1

data/ext/system/input_stream.c

@@ -16,21 +16,20 @@ typedef struct {
 
 static VALUE rb_cInputStream;
 
-static void InputStream_mark(void *ptr) {
-    InputStream *stream = ptr;
+static void InputStream_mark(void* ptr) {
+    InputStream* stream = ptr;
 
     rb_gc_mark(stream->rb_io);
 }
 
-static void InputStream_free(void *ptr) {
+static void InputStream_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t InputStream_data_type = {
     .wrap_struct_name = "SFML::InputStream",
     .function = {.dmark = InputStream_mark, .dfree = InputStream_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
 /* Callbacks run from C++ (SFML), so a Ruby exception must never unwind through
    those frames. Each body runs under rb_protect and reports failure as a
@@ -38,12 +37,12 @@ static const rb_data_type_t InputStream_data_type = {
 typedef struct {
     VALUE io;
     size_t size;
-    void *data;
+    void* data;
     int64_t result;
 } ReadContext;
 
 static VALUE InputStream_read_body(VALUE v) {
-    ReadContext *ctx = (ReadContext *) v;
+    ReadContext* ctx = (ReadContext*)v;
     VALUE str = rb_funcall(ctx->io, rb_intern("read"), 1, SIZET2NUM(ctx->size));
 
     if (NIL_P(str)) {
@@ -55,25 +54,31 @@ static VALUE InputStream_read_body(VALUE v) {
 
     long length = RSTRING_LEN(str);
 
-    if ((size_t) length > ctx->size) {
-        length = (long) ctx->size;
+    if ((size_t)length > ctx->size) {
+        length = (long)ctx->size;
     }
 
     if (length > 0) {
-        memcpy(ctx->data, RSTRING_PTR(str), (size_t) length);
+        const unsigned char* src = (const unsigned char*)RSTRING_PTR(str);
+        unsigned char* dest = ctx->data;
+        long i;
+
+        for (i = 0; i < length; i++) {
+            dest[i] = src[i];
+        }
     }
 
-    ctx->result = (int64_t) length;
+    ctx->result = (int64_t)length;
 
     return Qnil;
 }
 
-static int64_t InputStream_read(void *data, size_t size, void *userData) {
-    InputStream *stream = userData;
+static int64_t InputStream_read(void* data, size_t size, void* userData) {
+    InputStream* stream = userData;
     ReadContext ctx = {.io = stream->rb_io, .size = size, .data = data, .result = -1};
     int state = 0;
 
-    rb_protect(InputStream_read_body, (VALUE) &ctx, &state);
+    rb_protect(InputStream_read_body, (VALUE)&ctx, &state);
 
     if (state) {
         rb_set_errinfo(Qnil);
@@ -90,20 +95,20 @@ typedef struct {
 } SeekContext;
 
 static VALUE InputStream_seek_body(VALUE v) {
-    SeekContext *ctx = (SeekContext *) v;
+    SeekContext* ctx = (SeekContext*)v;
 
     rb_funcall(ctx->io, rb_intern("seek"), 2, SIZET2NUM(ctx->position), INT2NUM(SEEK_SET));
-    ctx->result = (int64_t) ctx->position;
+    ctx->result = (int64_t)ctx->position;
 
     return Qnil;
 }
 
-static int64_t InputStream_seek(size_t position, void *userData) {
-    InputStream *stream = userData;
+static int64_t InputStream_seek(size_t position, void* userData) {
+    InputStream* stream = userData;
     SeekContext ctx = {.io = stream->rb_io, .position = position, .result = -1};
     int state = 0;
 
-    rb_protect(InputStream_seek_body, (VALUE) &ctx, &state);
+    rb_protect(InputStream_seek_body, (VALUE)&ctx, &state);
 
     if (state) {
         rb_set_errinfo(Qnil);
@@ -113,82 +118,139 @@ static int64_t InputStream_seek(size_t position, void *userData) {
     return ctx.result;
 }
 
+typedef struct {
+    VALUE io;
+    int64_t result;
+} Int64Context;
+
+/* NUM2LL is done here, inside the rb_protect-called body, rather than after
+   rb_protect returns: if the IO's #tell/#pos/#size/#length returns something
+   that doesn't convert cleanly to a C integer (a String, nil, a Bignum too
+   large for int64_t, a #to_int that itself raises), NUM2LL raises directly --
+   and unprotected, that exception would unwind straight through CSFML's (and
+   possibly SFML's C++) stack frames, exactly what rb_protect exists to
+   prevent here. */
 static VALUE InputStream_tell_body(VALUE v) {
-    VALUE io = (VALUE) v;
+    Int64Context* ctx = (Int64Context*)v;
+    VALUE result;
 
-    if (rb_respond_to(io, rb_intern("tell"))) {
-        return rb_funcall(io, rb_intern("tell"), 0);
+    if (rb_respond_to(ctx->io, rb_intern("tell"))) {
+        result = rb_funcall(ctx->io, rb_intern("tell"), 0);
+    } else {
+        result = rb_funcall(ctx->io, rb_intern("pos"), 0);
     }
 
-    return rb_funcall(io, rb_intern("pos"), 0);
+    ctx->result = NUM2LL(result);
+
+    return Qnil;
 }
 
-static int64_t InputStream_tell(void *userData) {
-    InputStream *stream = userData;
+static int64_t InputStream_tell(void* userData) {
+    InputStream* stream = userData;
+    Int64Context ctx = {.io = stream->rb_io, .result = -1};
     int state = 0;
-    VALUE result = rb_protect(InputStream_tell_body, stream->rb_io, &state);
+
+    rb_protect(InputStream_tell_body, (VALUE)&ctx, &state);
 
     if (state) {
         rb_set_errinfo(Qnil);
         return -1;
     }
 
-    return NUM2LL(result);
+    return ctx.result;
 }
 
 static VALUE InputStream_get_size_body(VALUE v) {
-    VALUE io = (VALUE) v;
+    Int64Context* ctx = (Int64Context*)v;
+    VALUE result;
 
-    if (rb_respond_to(io, rb_intern("size"))) {
-        return rb_funcall(io, rb_intern("size"), 0);
+    if (rb_respond_to(ctx->io, rb_intern("size"))) {
+        result = rb_funcall(ctx->io, rb_intern("size"), 0);
+    } else {
+        result = rb_funcall(ctx->io, rb_intern("length"), 0);
     }
 
-    return rb_funcall(io, rb_intern("length"), 0);
+    ctx->result = NUM2LL(result);
+
+    return Qnil;
 }
 
-static int64_t InputStream_get_size(void *userData) {
-    InputStream *stream = userData;
+static int64_t InputStream_get_size(void* userData) {
+    InputStream* stream = userData;
+    Int64Context ctx = {.io = stream->rb_io, .result = -1};
     int state = 0;
-    VALUE result = rb_protect(InputStream_get_size_body, stream->rb_io, &state);
+
+    rb_protect(InputStream_get_size_body, (VALUE)&ctx, &state);
 
     if (state) {
         rb_set_errinfo(Qnil);
         return -1;
     }
 
-    return NUM2LL(result);
+    return ctx.result;
 }
 
-static VALUE InputStream_new(VALUE klass, VALUE rb_io) {
-    VALUE self;
-    InputStream *stream;
+static VALUE InputStream_alloc(VALUE klass) {
+    InputStream* stream = malloc(sizeof(InputStream));
 
-    if (!rb_respond_to(rb_io, rb_intern("read"))) {
-        rb_raise(rb_eArgError, "stream object must respond to #read");
+    if (stream == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate input stream");
     }
 
-    stream = malloc(sizeof(InputStream));
-
-    stream->rb_io = rb_io;
+    stream->rb_io = Qnil;
     stream->stream.read = InputStream_read;
     stream->stream.seek = InputStream_seek;
     stream->stream.tell = InputStream_tell;
     stream->stream.getSize = InputStream_get_size;
     stream->stream.userData = stream;
 
-    self = TypedData_Wrap_Struct(klass, &InputStream_data_type, stream);
+    return TypedData_Wrap_Struct(klass, &InputStream_data_type, stream);
+}
+
+/* call-seq:
+ *   InputStream.new(io) -> InputStream
+ *
+ * Wraps a Ruby object that responds to +#read+ (and ideally +#seek+/+#tell+
+ * or +#pos+, and +#size+ or +#length+) so it can be passed anywhere the
+ * library accepts a stream-based data source.
+ *
+ * @return [InputStream]
+ * @raise [ArgumentError] if +io+ does not respond to +#read+
+ */
+static VALUE InputStream_initialize(VALUE self, VALUE rb_io) {
+    InputStream* stream;
+
+    if (!rb_respond_to(rb_io, rb_intern("read"))) {
+        rb_raise(rb_eArgError, "stream object must respond to #read");
+    }
+
+    TypedData_Get_Struct(self, InputStream, &InputStream_data_type, stream);
+
+    stream->rb_io = rb_io;
 
     return self;
 }
 
+/* call-seq: io -> Object
+ *
+ * Returns the IO-like object the stream was created from.
+ *
+ * @return [Object] the wrapped IO-like object
+ */
 static VALUE InputStream_get_io(VALUE self) {
-    return ((InputStream *) Get_InputStream_Struct(self))->rb_io;
+    return ((InputStream*)Get_InputStream_Struct(self))->rb_io;
 }
 
-void Init_InputStream(VALUE rb_module) {
-    rb_cInputStream = rb_define_class_under(rb_module, "InputStream", rb_cObject);
+/* Document-class: SFML::InputStream
+ * Adapts any Ruby object that responds to +#read+ into the stream interface
+ * SFML's loaders expect, so resources can be loaded from something other
+ * than a filesystem path (e.g. an in-memory StringIO, or a custom source).
+ */
+void Init_InputStream(VALUE rb_mSFML) {
+    rb_cInputStream = rb_define_class_under(rb_mSFML, "InputStream", rb_cObject);
 
-    rb_define_singleton_method(rb_cInputStream, "new", InputStream_new, 1);
+    rb_define_alloc_func(rb_cInputStream, InputStream_alloc);
+    rb_define_method(rb_cInputStream, "initialize", InputStream_initialize, 1);
 
     rb_define_method(rb_cInputStream, "io", InputStream_get_io, 0);
 }
@@ -197,8 +259,8 @@ VALUE Get_Klass_InputStream(void) {
     return rb_cInputStream;
 }
 
-sfInputStream *Get_InputStream_Struct(VALUE self) {
-    InputStream *ptr;
+sfInputStream* Get_InputStream_Struct(VALUE self) {
+    InputStream* ptr;
     TypedData_Get_Struct(self, InputStream, &InputStream_data_type, ptr);
     return &ptr->stream;
 }
@@ -207,7 +269,7 @@ int InputStream_is_stream(VALUE rb_stream) {
     return rb_obj_is_kind_of(rb_stream, rb_cInputStream) ? 1 : 0;
 }
 
-sfInputStream *input_stream_from_rb(VALUE rb_stream, VALUE *holder) {
+sfInputStream* input_stream_from_rb(VALUE rb_stream, VALUE* holder) {
     if (InputStream_is_stream(rb_stream)) {
         return Get_InputStream_Struct(rb_stream);
     }

data/ext/system/sleep.c

@@ -5,12 +5,20 @@
 #include "system/time.h"
 #include "core/sfml.h"
 
+/* call-seq:
+ *   SFML.sleep(duration) -> duration
+ *
+ * Blocks the calling thread for +duration+, which may be a Time, a number
+ * of seconds, or anything #to_f-convertible.
+ *
+ * @return [Time, Numeric] +duration+
+ */
 static VALUE Sleep_sleep(VALUE module, VALUE rb_duration) {
     sfSleep(time_from_rb(rb_duration));
 
     return rb_duration;
 }
 
-void Init_Sleep(VALUE rb_module) {
-    rb_define_module_function(rb_module, "sleep", Sleep_sleep, 1);
+void Init_Sleep(VALUE rb_mSFML) {
+    rb_define_module_function(rb_mSFML, "sleep", Sleep_sleep, 1);
 }

data/ext/system/time.c

@@ -12,121 +12,240 @@ typedef struct {
 
 static VALUE rb_cSFTime;
 
-static void Time_free(void *ptr) {
+static void Time_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t Time_data_type = {
     .wrap_struct_name = "SFML::Time",
     .function = {.dmark = NULL, .dfree = Time_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
 static VALUE Time_wrap(sfTime time) {
-    Time *ptr = malloc(sizeof(Time));
+    Time* ptr = malloc(sizeof(Time));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate time");
+    }
 
     ptr->time = time;
 
     return TypedData_Wrap_Struct(rb_cSFTime, &Time_data_type, ptr);
 }
 
-static VALUE Time_new(int argc, VALUE *argv, VALUE klass) {
-    VALUE self;
-    Time *ptr;
+static VALUE Time_alloc(VALUE klass) {
+    Time* ptr = malloc(sizeof(Time));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate time");
+    }
+
+    ptr->time = sfTime_Zero;
+
+    return TypedData_Wrap_Struct(klass, &Time_data_type, ptr);
+}
+
+/* call-seq:
+ *   Time.new             -> Time(0)
+ *   Time.new(seconds)    -> Time
+ *   Time.new(microseconds_integer) -> Time
+ *   Time.new(other_time) -> copy of +other_time+
+ *
+ * A Float argument is interpreted as seconds; an Integer argument is
+ * interpreted as microseconds. Prefer .seconds/.milliseconds/.microseconds
+ * to be explicit.
+ *
+ * @return [Time]
+ * @raise [ArgumentError] if given more than one argument
+ */
+static VALUE Time_initialize(int argc, VALUE* argv, VALUE self) {
     sfTime time = sfTime_Zero;
 
     if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cSFTime)) {
-        time = ((Time *) Get_Time_Struct(argv[0]))->time;
+        time = ((Time*)Get_Time_Struct(argv[0]))->time;
     } else if (argc == 1 && RB_INTEGER_TYPE_P(argv[0])) {
-        time = sfMicroseconds((int64_t) NUM2LL(argv[0]));
+        time = sfMicroseconds((int64_t)NUM2LL(argv[0]));
     } else if (argc == 1) {
-        time = sfSeconds((float) NUM2DBL(argv[0]));
+        time = sfSeconds((float)NUM2DBL(argv[0]));
     } else if (argc != 0) {
         raise_invalid_arguments_excepted(1, argc);
     }
 
-    ptr = malloc(sizeof(Time));
-    ptr->time = time;
-
-    self = TypedData_Wrap_Struct(klass, &Time_data_type, ptr);
+    ((Time*)Get_Time_Struct(self))->time = time;
 
     return self;
 }
 
+/* call-seq:
+ *   Time.seconds(value) -> Time
+ *
+ * Creates a Time of +value+ seconds, where +value+ is any Float-convertible
+ * number.
+ *
+ * @return [Time]
+ */
 static VALUE Time_seconds(VALUE klass, VALUE rb_seconds) {
-    return Time_wrap(sfSeconds((float) NUM2DBL(rb_seconds)));
+    return Time_wrap(sfSeconds((float)NUM2DBL(rb_seconds)));
 }
 
+/* call-seq:
+ *   Time.milliseconds(value) -> Time
+ *
+ * Creates a Time of +value+ milliseconds.
+ *
+ * @return [Time]
+ */
 static VALUE Time_milliseconds(VALUE klass, VALUE rb_milliseconds) {
-    return Time_wrap(sfMilliseconds((int32_t) NUM2INT(rb_milliseconds)));
+    return Time_wrap(sfMilliseconds((int32_t)NUM2INT(rb_milliseconds)));
 }
 
+/* call-seq:
+ *   Time.microseconds(value) -> Time
+ *
+ * Creates a Time of +value+ microseconds.
+ *
+ * @return [Time]
+ */
 static VALUE Time_microseconds(VALUE klass, VALUE rb_microseconds) {
-    return Time_wrap(sfMicroseconds((int64_t) NUM2LL(rb_microseconds)));
+    return Time_wrap(sfMicroseconds((int64_t)NUM2LL(rb_microseconds)));
 }
 
+/* call-seq:
+ *   Time.zero -> Time
+ *
+ * Returns the zero-duration Time.
+ *
+ * @return [Time] a zero-duration Time
+ */
 static VALUE Time_zero(VALUE klass) {
     return Time_wrap(sfTime_Zero);
 }
 
+/* call-seq: as_seconds -> Float
+ *
+ * Returns the duration expressed in seconds.
+ *
+ * @return [Float]
+ */
 static VALUE Time_as_seconds(VALUE self) {
-    return DBL2NUM(sfTime_asSeconds(((Time *) Get_Time_Struct(self))->time));
+    return DBL2NUM(sfTime_asSeconds(((Time*)Get_Time_Struct(self))->time));
 }
 
+/* call-seq: as_milliseconds -> Integer
+ *
+ * Returns the duration expressed in whole milliseconds.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_as_milliseconds(VALUE self) {
-    return INT2NUM(sfTime_asMilliseconds(((Time *) Get_Time_Struct(self))->time));
+    return INT2NUM(sfTime_asMilliseconds(((Time*)Get_Time_Struct(self))->time));
 }
 
+/* call-seq: as_microseconds -> Integer
+ *
+ * Returns the duration expressed in whole microseconds.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_as_microseconds(VALUE self) {
-    return LL2NUM(sfTime_asMicroseconds(((Time *) Get_Time_Struct(self))->time));
+    return LL2NUM(sfTime_asMicroseconds(((Time*)Get_Time_Struct(self))->time));
 }
 
+/* call-seq: to_f -> Float
+ *
+ * Alias for #as_seconds.
+ *
+ * @return [Float]
+ */
 static VALUE Time_to_f(VALUE self) {
     return Time_as_seconds(self);
 }
 
+/* call-seq: to_i -> Integer
+ *
+ * Alias for #as_microseconds.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_to_i(VALUE self) {
     return Time_as_microseconds(self);
 }
 
+/* call-seq:
+ *   self + other -> Time
+ *
+ * Adds +other+ to the duration, returning a new Time.
+ *
+ * @return [Time]
+ */
 static VALUE Time_add(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
     sfTime b = time_from_rb(rb_other);
 
     return Time_wrap(sfMicroseconds(sfTime_asMicroseconds(a) + sfTime_asMicroseconds(b)));
 }
 
+/* call-seq:
+ *   self - other -> Time
+ *
+ * Subtracts +other+ from the duration, returning a new Time.
+ *
+ * @return [Time]
+ */
 static VALUE Time_sub(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
     sfTime b = time_from_rb(rb_other);
 
     return Time_wrap(sfMicroseconds(sfTime_asMicroseconds(a) - sfTime_asMicroseconds(b)));
 }
 
+/* call-seq:
+ *   self * scalar -> Time
+ *
+ * Scales the duration by +scalar+, returning a new Time.
+ *
+ * @return [Time]
+ */
 static VALUE Time_mul(VALUE self, VALUE rb_scalar) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
 
-    return Time_wrap(sfMicroseconds((int64_t) (sfTime_asMicroseconds(a) * NUM2DBL(rb_scalar))));
+    return Time_wrap(sfMicroseconds((int64_t)(sfTime_asMicroseconds(a) * NUM2DBL(rb_scalar))));
 }
 
+/* call-seq:
+ *   self / other -> Time or Float
+ *
+ * Dividing by a Time returns the (unitless) ratio of the two durations as a
+ * Float; dividing by a Number scales the duration.
+ *
+ * @return [Time, Float]
+ * @raise [ZeroDivError] if dividing by a zero Time
+ */
 static VALUE Time_div(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
 
     if (rb_obj_is_kind_of(rb_other, rb_cSFTime)) {
-        int64_t b = sfTime_asMicroseconds(((Time *) Get_Time_Struct(rb_other))->time);
+        int64_t b = sfTime_asMicroseconds(((Time*)Get_Time_Struct(rb_other))->time);
 
         if (b == 0) {
             rb_raise(rb_eZeroDivError, "divided by 0");
         }
 
-        return DBL2NUM((double) sfTime_asMicroseconds(a) / (double) b);
+        return DBL2NUM((double)sfTime_asMicroseconds(a) / (double)b);
     }
 
-    return Time_wrap(sfMicroseconds((int64_t) (sfTime_asMicroseconds(a) / NUM2DBL(rb_other))));
+    return Time_wrap(sfMicroseconds((int64_t)(sfTime_asMicroseconds(a) / NUM2DBL(rb_other))));
 }
 
+/* call-seq:
+ *   self <=> other -> -1, 0 or 1
+ *
+ * Compares the duration with +other+, which may be a Time or a number.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_cmp(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
     sfTime b = time_from_rb(rb_other);
     int64_t micro_a = sfTime_asMicroseconds(a);
     int64_t micro_b = sfTime_asMicroseconds(b);
@@ -142,29 +261,52 @@ static VALUE Time_cmp(VALUE self, VALUE rb_other) {
     return INT2NUM(0);
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * Returns +true+ if +other+ is a Time holding the same duration.
+ *
+ * @return [Boolean]
+ */
 static VALUE Time_eql(VALUE self, VALUE rb_other) {
     if (!rb_obj_is_kind_of(rb_other, rb_cSFTime)) {
         return Qfalse;
     }
 
-    return BOOL2RB(sfTime_asMicroseconds(((Time *) Get_Time_Struct(self))->time) ==
-                   sfTime_asMicroseconds(((Time *) Get_Time_Struct(rb_other))->time));
+    return BOOL2RB(sfTime_asMicroseconds(((Time*)Get_Time_Struct(self))->time) ==
+                   sfTime_asMicroseconds(((Time*)Get_Time_Struct(rb_other))->time));
 }
 
+/* call-seq: to_s -> String
+ *
+ * Returns the duration formatted as a number of seconds.
+ *
+ * @return [String] +"N s"+, e.g. +"1.5 s"+
+ */
 static VALUE Time_to_s(VALUE self) {
     char buffer[64];
 
-    snprintf(buffer, sizeof(buffer), "%g s", sfTime_asSeconds(((Time *) Get_Time_Struct(self))->time));
+    snprintf(buffer, sizeof(buffer), "%g s",
+             sfTime_asSeconds(((Time*)Get_Time_Struct(self))->time));
 
     return rb_str_new2(buffer);
 }
 
-void Init_Time(VALUE rb_module) {
-    rb_cSFTime = rb_define_class_under(rb_module, "Time", rb_cObject);
+/* Document-class: SFML::Time
+ * A time duration, with microsecond precision internally. Used throughout
+ * the library wherever a duration or timestamp is needed (Clock#elapsed_time,
+ * SoundSource#playing_offset, sleep, animation timers, ...).
+ *
+ * Includes +Comparable+.
+ */
+void Init_Time(VALUE rb_mSFML) {
+    rb_cSFTime = rb_define_class_under(rb_mSFML, "Time", rb_cObject);
 
     rb_include_module(rb_cSFTime, rb_mComparable);
 
-    rb_define_singleton_method(rb_cSFTime, "new", Time_new, -1);
+    rb_define_alloc_func(rb_cSFTime, Time_alloc);
+    rb_define_method(rb_cSFTime, "initialize", Time_initialize, -1);
+
     rb_define_singleton_method(rb_cSFTime, "seconds", Time_seconds, 1);
     rb_define_singleton_method(rb_cSFTime, "milliseconds", Time_milliseconds, 1);
     rb_define_singleton_method(rb_cSFTime, "microseconds", Time_microseconds, 1);
@@ -189,23 +331,23 @@ VALUE Get_Klass_Time(void) {
     return rb_cSFTime;
 }
 
-void *Get_Time_Struct(VALUE self) {
-    Time *ptr;
+void* Get_Time_Struct(VALUE self) {
+    Time* ptr;
     TypedData_Get_Struct(self, Time, &Time_data_type, ptr);
     return ptr;
 }
 
 sfTime time_from_rb(VALUE rb_time) {
     if (rb_obj_is_kind_of(rb_time, rb_cSFTime)) {
-        return ((Time *) Get_Time_Struct(rb_time))->time;
+        return ((Time*)Get_Time_Struct(rb_time))->time;
     }
 
     if (RB_INTEGER_TYPE_P(rb_time)) {
-        return sfMicroseconds((int64_t) NUM2LL(rb_time));
+        return sfMicroseconds((int64_t)NUM2LL(rb_time));
     }
 
     if (RB_FLOAT_TYPE_P(rb_time) || RB_TYPE_P(rb_time, T_RATIONAL)) {
-        return sfSeconds((float) NUM2DBL(rb_time));
+        return sfSeconds((float)NUM2DBL(rb_time));
     }
 
     raise_invalid_argument_class(rb_cSFTime);