sfml3-rb 0.3.0 → 0.3.1

data/ext/graphics/vertex.c

@@ -31,6 +31,18 @@ static VALUE Vertex_wrap(sfVertex vertex) {
     return TypedData_Wrap_Struct(rb_cVertex, &Vertex_data_type, ptr);
 }
 
+static VALUE Vertex_alloc(VALUE klass) {
+    Vertex* ptr = malloc(sizeof(Vertex));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vertex");
+    }
+
+    ptr->vertex = (sfVertex){{0, 0}, {0, 0, 0, 0}, {0, 0}};
+
+    return TypedData_Wrap_Struct(klass, &Vertex_data_type, ptr);
+}
+
 /* call-seq:
  *   Vertex.new                              -> Vertex
  *   Vertex.new(position)                    -> Vertex
@@ -42,7 +54,7 @@ static VALUE Vertex_wrap(sfVertex vertex) {
  *
  * @return [Vertex]
  */
-static VALUE Vertex_new(int argc, VALUE* argv, VALUE klass) {
+static VALUE Vertex_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_position, rb_color, rb_tex_coords;
     sfVertex vertex = {{0, 0}, {255, 255, 255, 255}, {0, 0}};
 
@@ -60,7 +72,9 @@ static VALUE Vertex_new(int argc, VALUE* argv, VALUE klass) {
         vertex.texCoords = vec2f_from_rb(rb_tex_coords);
     }
 
-    return Vertex_wrap(vertex);
+    ((Vertex*)Get_Vertex_Struct(self))->vertex = vertex;
+
+    return self;
 }
 
 /* call-seq: position -> Vector2
@@ -181,7 +195,8 @@ static VALUE Vertex_eql(VALUE self, VALUE rb_other) {
 void Init_Vertex(VALUE rb_mSFML) {
     rb_cVertex = rb_define_class_under(rb_mSFML, "Vertex", rb_cObject);
 
-    rb_define_singleton_method(rb_cVertex, "new", Vertex_new, -1);
+    rb_define_alloc_func(rb_cVertex, Vertex_alloc);
+    rb_define_method(rb_cVertex, "initialize", Vertex_initialize, -1);
 
     rb_define_method(rb_cVertex, "position", Vertex_get_position, 0);
     rb_define_method(rb_cVertex, "color", Vertex_get_color, 0);

data/ext/graphics/vertex_array.c

@@ -37,6 +37,16 @@ static sfVertexArray* Get_VertexArray_Struct(VALUE self) {
     return ptr;
 }
 
+static VALUE VertexArray_alloc(VALUE klass) {
+    sfVertexArray* array = sfVertexArray_create();
+
+    if (array == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create vertex array");
+    }
+
+    return TypedData_Wrap_Struct(klass, &VertexArray_data_type, array);
+}
+
 /* call-seq:
  *   VertexArray.new -> VertexArray
  *
@@ -44,8 +54,8 @@ static sfVertexArray* Get_VertexArray_Struct(VALUE self) {
  *
  * @return [VertexArray] an empty array of :points primitives
  */
-static VALUE VertexArray_new(VALUE klass) {
-    return VertexArray_wrap(klass, sfVertexArray_create());
+static VALUE VertexArray_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq: copy -> VertexArray
@@ -189,17 +199,14 @@ static VALUE VertexArray_get_bounds(VALUE self) {
  *   RenderState
  */
 static VALUE VertexArray_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
-    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
-        raise_invalid_argument_class(Get_Klass_Target());
-    }
+    TargetView view = Get_RenderTarget_View(rb_target);
 
     if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
         raise_invalid_argument_class(Get_Klass_RenderState());
     }
 
-    TARGET_DRAW(Get_Target_Struct(rb_target), sfRenderWindow_drawVertexArray,
-                sfRenderTexture_drawVertexArray, Get_VertexArray_Struct(self),
-                Get_RenderState_Struct(rb_state));
+    TARGET_DRAW(view, sfRenderWindow_drawVertexArray, sfRenderTexture_drawVertexArray,
+                Get_VertexArray_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
@@ -217,9 +224,11 @@ static VALUE VertexArray_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_VertexArray(VALUE rb_mSFML) {
     rb_cVertexArray = rb_define_class_under(rb_mSFML, "VertexArray", rb_cObject);
 
+    rb_define_alloc_func(rb_cVertexArray, VertexArray_alloc);
+
     rb_include_module(rb_cVertexArray, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cVertexArray, "new", VertexArray_new, 0);
+    rb_define_method(rb_cVertexArray, "initialize", VertexArray_initialize, 0);
 
     rb_define_method(rb_cVertexArray, "copy", VertexArray_copy, 0);
     rb_define_method(rb_cVertexArray, "vertex_count", VertexArray_get_vertex_count, 0);

data/ext/graphics/vertex_buffer.c

@@ -17,7 +17,9 @@ static VALUE rb_cVertexBuffer;
 static const char* usage_names[] = {"stream", "dynamic", "static"};
 
 static void VertexBuffer_free(void* ptr) {
-    sfVertexBuffer_destroy(ptr);
+    if (ptr != NULL) {
+        sfVertexBuffer_destroy(ptr);
+    }
 }
 
 static const rb_data_type_t VertexBuffer_data_type = {
@@ -60,6 +62,15 @@ static sfVertexBufferUsage usage_from_rb(VALUE rb_usage) {
     return sfVertexBufferStatic;
 }
 
+static VALUE VertexBuffer_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+static VALUE VertexBuffer_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &VertexBuffer_data_type, NULL);
+}
+
 /* call-seq:
  *   VertexBuffer.new                                    -> VertexBuffer
  *   VertexBuffer.new(count)                             -> VertexBuffer
@@ -74,11 +85,12 @@ static sfVertexBufferUsage usage_from_rb(VALUE rb_usage) {
  * @return [VertexBuffer]
  * @raise [RuntimeError] if creation fails
  */
-static VALUE VertexBuffer_new(int argc, VALUE* argv, VALUE klass) {
+static VALUE VertexBuffer_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_count, rb_primitive, rb_usage;
     size_t count = 0;
     sfPrimitiveType primitive = sfPoints;
     sfVertexBufferUsage usage = sfVertexBufferStatic;
+    sfVertexBuffer* buffer;
 
     rb_scan_args(argc, argv, "03", &rb_count, &rb_primitive, &rb_usage);
 
@@ -94,7 +106,15 @@ static VALUE VertexBuffer_new(int argc, VALUE* argv, VALUE klass) {
         usage = usage_from_rb(rb_usage);
     }
 
-    return VertexBuffer_wrap(klass, sfVertexBuffer_create(count, primitive, usage));
+    buffer = sfVertexBuffer_create(count, primitive, usage);
+
+    if (buffer == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create vertex buffer");
+    }
+
+    DATA_PTR(self) = buffer;
+
+    return self;
 }
 
 /* call-seq: copy -> VertexBuffer
@@ -277,17 +297,14 @@ static VALUE VertexBuffer_is_available(VALUE klass) {
  *   RenderState
  */
 static VALUE VertexBuffer_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
-    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
-        raise_invalid_argument_class(Get_Klass_Target());
-    }
+    TargetView view = Get_RenderTarget_View(rb_target);
 
     if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
         raise_invalid_argument_class(Get_Klass_RenderState());
     }
 
-    TARGET_DRAW(Get_Target_Struct(rb_target), sfRenderWindow_drawVertexBuffer,
-                sfRenderTexture_drawVertexBuffer, Get_VertexBuffer_Struct(self),
-                Get_RenderState_Struct(rb_state));
+    TARGET_DRAW(view, sfRenderWindow_drawVertexBuffer, sfRenderTexture_drawVertexBuffer,
+                Get_VertexBuffer_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
@@ -309,9 +326,12 @@ static VALUE VertexBuffer_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_VertexBuffer(VALUE rb_mSFML) {
     rb_cVertexBuffer = rb_define_class_under(rb_mSFML, "VertexBuffer", rb_cObject);
 
+    rb_define_alloc_func(rb_cVertexBuffer, VertexBuffer_alloc);
+
     rb_include_module(rb_cVertexBuffer, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cVertexBuffer, "new", VertexBuffer_new, -1);
+    rb_define_method(rb_cVertexBuffer, "initialize", VertexBuffer_initialize, -1);
+    rb_define_private_method(rb_cVertexBuffer, "initialize_copy", VertexBuffer_initialize_copy, 1);
     rb_define_singleton_method(rb_cVertexBuffer, "available?", VertexBuffer_is_available, 0);
 
     rb_define_method(rb_cVertexBuffer, "copy", VertexBuffer_copy, 0);

data/ext/graphics/view.c

@@ -42,15 +42,14 @@ static VALUE View_new_from(VALUE klass, sfView* c_view) {
     return self;
 }
 
-/* call-seq:
- *   View.new -> View
- *
- * Creates a default view covering the (0, 0) - (1000, 1000) region.
- *
- * @return [View]
- */
-static VALUE View_new(VALUE klass) {
-    return View_new_from(klass, NULL);
+static VALUE View_alloc(VALUE klass) {
+    sfView* view = View_create();
+
+    if (view == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create view");
+    }
+
+    return TypedData_Wrap_Struct(klass, &View_data_type, view);
 }
 
 /* The rect is the visible area: position is the top-left corner, not the
@@ -67,6 +66,13 @@ static VALUE View_s_from_rect(VALUE klass, VALUE rb_rect) {
     return View_new_from(klass, sfView_createFromRect(rect_from_rb(rb_rect)));
 }
 
+/* call-seq:
+ *   View.new -> View
+ *
+ * Creates a default view covering the (0, 0) - (1000, 1000) region.
+ *
+ * @return [View]
+ */
 static VALUE View_init(VALUE self) {
     return self;
 }
@@ -257,7 +263,7 @@ static VALUE View_copy(VALUE self) {
 void Init_View(VALUE rb_mSFML) {
     rb_cView = rb_define_class_under(rb_mSFML, "View", rb_cObject);
 
-    rb_define_singleton_method(rb_cView, "new", View_new, 0);
+    rb_define_alloc_func(rb_cView, View_alloc);
     rb_define_singleton_method(rb_cView, "from_rect", View_s_from_rect, 1);
 
     // methods

data/ext/network/ftp.c

@@ -130,6 +130,29 @@ static VALUE FtpListingResponse_wrap(sfFtpListingResponse* handle) {
     return TypedData_Wrap_Struct(rb_cFtpListingResponse, &FtpListingResponse_data_type, ptr);
 }
 
+static VALUE Ftp_alloc(VALUE klass) {
+    (void)klass;
+    return Ftp_wrap(sfFtp_create());
+}
+
+static VALUE FtpResponse_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "FTP response objects are returned by Ftp methods and cannot be "
+                              "constructed directly");
+}
+
+static VALUE FtpDirectoryResponse_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "FTP response objects are returned by Ftp methods and cannot be "
+                              "constructed directly");
+}
+
+static VALUE FtpListingResponse_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "FTP response objects are returned by Ftp methods and cannot be "
+                              "constructed directly");
+}
+
 /* call-seq:
  *   Ftp.new -> Ftp
  *
@@ -137,8 +160,8 @@ static VALUE FtpListingResponse_wrap(sfFtpListingResponse* handle) {
  *
  * @return [Ftp]
  */
-static VALUE Ftp_new(VALUE klass) {
-    return Ftp_wrap(sfFtp_create());
+static VALUE Ftp_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq:
@@ -550,22 +573,26 @@ static VALUE FtpListingResponse_name(VALUE self, VALUE rb_index) {
  */
 void Init_Ftp(VALUE rb_mSFML) {
     rb_cFtp = rb_define_class_under(rb_mSFML, "Ftp", rb_cObject);
+    rb_define_alloc_func(rb_cFtp, Ftp_alloc);
     /* Document-class: SFML::FtpResponse
      * The status and message returned by most Ftp commands.
      */
     rb_cFtpResponse = rb_define_class_under(rb_mSFML, "FtpResponse", rb_cObject);
+    rb_define_alloc_func(rb_cFtpResponse, FtpResponse_alloc);
     /* Document-class: SFML::FtpDirectoryResponse
      * An FtpResponse specialization returned by Ftp#working_directory,
      * additionally carrying the directory path.
      */
     rb_cFtpDirectoryResponse = rb_define_class_under(rb_mSFML, "FtpDirectoryResponse", rb_cObject);
+    rb_define_alloc_func(rb_cFtpDirectoryResponse, FtpDirectoryResponse_alloc);
     /* Document-class: SFML::FtpListingResponse
      * An FtpResponse specialization returned by Ftp#directory_listing,
      * additionally carrying the list of filenames.
      */
     rb_cFtpListingResponse = rb_define_class_under(rb_mSFML, "FtpListingResponse", rb_cObject);
+    rb_define_alloc_func(rb_cFtpListingResponse, FtpListingResponse_alloc);
 
-    rb_define_singleton_method(rb_cFtp, "new", Ftp_new, 0);
+    rb_define_method(rb_cFtp, "initialize", Ftp_initialize, 0);
 
     rb_define_method(rb_cFtp, "connect", Ftp_connect, -1);
     rb_define_method(rb_cFtp, "login_anonymous", Ftp_login_anonymous, 0);

data/ext/network/http.c

@@ -98,6 +98,20 @@ static VALUE HttpResponse_wrap(sfHttpResponse* handle) {
     return TypedData_Wrap_Struct(rb_cHttpResponse, &HttpResponse_data_type, ptr);
 }
 
+static VALUE Http_alloc(VALUE klass) {
+    return Http_wrap(klass, sfHttp_create());
+}
+
+static VALUE HttpRequest_alloc(VALUE klass) {
+    return HttpRequest_wrap(klass, sfHttpRequest_create());
+}
+
+static VALUE HttpResponse_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "HTTP responses are returned by Http#send_request and cannot be "
+                              "constructed directly");
+}
+
 /* call-seq:
  *   Http.new -> Http
  *
@@ -105,8 +119,8 @@ static VALUE HttpResponse_wrap(sfHttpResponse* handle) {
  *
  * @return [Http]
  */
-static VALUE Http_new(VALUE klass) {
-    return Http_wrap(klass, sfHttp_create());
+static VALUE Http_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq:
@@ -159,8 +173,8 @@ static VALUE Http_send_request(int argc, VALUE* argv, VALUE self) {
  * @return [HttpRequest] a new request, defaulting to a GET of +"/"+ over
  *   HTTP/1.0 with no fields or body
  */
-static VALUE HttpRequest_new(VALUE klass) {
-    return HttpRequest_wrap(klass, sfHttpRequest_create());
+static VALUE HttpRequest_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq:
@@ -301,17 +315,20 @@ static VALUE HttpResponse_body(VALUE self) {
  */
 void Init_Http(VALUE rb_mSFML) {
     rb_cHttp = rb_define_class_under(rb_mSFML, "Http", rb_cObject);
+    rb_define_alloc_func(rb_cHttp, Http_alloc);
     /* Document-class: SFML::HttpRequest
      * An HTTP request to send via Http#send_request.
      */
     rb_cHttpRequest = rb_define_class_under(rb_mSFML, "HttpRequest", rb_cObject);
+    rb_define_alloc_func(rb_cHttpRequest, HttpRequest_alloc);
     /* Document-class: SFML::HttpResponse
      * The status, headers and body returned by Http#send_request.
      */
     rb_cHttpResponse = rb_define_class_under(rb_mSFML, "HttpResponse", rb_cObject);
+    rb_define_alloc_func(rb_cHttpResponse, HttpResponse_alloc);
 
-    rb_define_singleton_method(rb_cHttp, "new", Http_new, 0);
-    rb_define_singleton_method(rb_cHttpRequest, "new", HttpRequest_new, 0);
+    rb_define_method(rb_cHttp, "initialize", Http_initialize, 0);
+    rb_define_method(rb_cHttpRequest, "initialize", HttpRequest_initialize, 0);
 
     rb_define_method(rb_cHttp, "set_host", Http_set_host, 2);
     rb_define_method(rb_cHttp, "send_request", Http_send_request, -1);

data/ext/network/ip_address.c

@@ -66,6 +66,18 @@ static VALUE IpAddress_from_integer(VALUE klass, VALUE rb_integer) {
     return ip_address_to_rb(sfIpAddress_fromInteger((uint32_t)NUM2UINT(rb_integer)));
 }
 
+static VALUE IpAddress_alloc(VALUE klass) {
+    IpAddress* ptr = malloc(sizeof(IpAddress));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate IP address");
+    }
+
+    ptr->address = sfIpAddress_None;
+
+    return TypedData_Wrap_Struct(klass, &IpAddress_data_type, ptr);
+}
+
 /* call-seq:
  *   IpAddress.new(address) -> IpAddress
  *
@@ -75,22 +87,20 @@ static VALUE IpAddress_from_integer(VALUE klass, VALUE rb_integer) {
  * @return [IpAddress]
  * @raise [TypeError] if +address+ is none of the above
  */
-static VALUE IpAddress_new(VALUE klass, VALUE rb_address) {
-    if (RB_INTEGER_TYPE_P(rb_address)) {
-        return IpAddress_from_integer(klass, rb_address);
-    }
-
-    if (RB_TYPE_P(rb_address, T_STRING)) {
-        return IpAddress_from_string(klass, rb_address);
-    }
+static VALUE IpAddress_initialize(VALUE self, VALUE rb_address) {
+    IpAddress* ptr = (IpAddress*)Get_IpAddress_Struct(self);
 
-    if (rb_obj_is_kind_of(rb_address, rb_cIpAddress)) {
-        return ip_address_to_rb(((IpAddress*)Get_IpAddress_Struct(rb_address))->address);
+    if (RB_INTEGER_TYPE_P(rb_address)) {
+        ptr->address = sfIpAddress_fromInteger((uint32_t)NUM2UINT(rb_address));
+    } else if (RB_TYPE_P(rb_address, T_STRING)) {
+        ptr->address = sfIpAddress_fromString(StringValueCStr(rb_address));
+    } else if (rb_obj_is_kind_of(rb_address, rb_cIpAddress)) {
+        ptr->address = ((IpAddress*)Get_IpAddress_Struct(rb_address))->address;
+    } else {
+        raise_invalid_argument_class(rb_cIpAddress);
     }
 
-    raise_invalid_argument_class(rb_cIpAddress);
-
-    return Qnil;
+    return self;
 }
 
 /* call-seq:
@@ -185,8 +195,9 @@ static VALUE IpAddress_hash(VALUE self) {
  */
 void Init_IpAddress(VALUE rb_mSFML) {
     rb_cIpAddress = rb_define_class_under(rb_mSFML, "IpAddress", rb_cObject);
+    rb_define_alloc_func(rb_cIpAddress, IpAddress_alloc);
 
-    rb_define_singleton_method(rb_cIpAddress, "new", IpAddress_new, 1);
+    rb_define_method(rb_cIpAddress, "initialize", IpAddress_initialize, 1);
     rb_define_singleton_method(rb_cIpAddress, "from_string", IpAddress_from_string, 1);
     rb_define_singleton_method(rb_cIpAddress, "from_bytes", IpAddress_from_bytes, 4);
     rb_define_singleton_method(rb_cIpAddress, "from_integer", IpAddress_from_integer, 1);

data/ext/network/packet.c

@@ -38,6 +38,10 @@ static VALUE Packet_wrap(VALUE klass, sfPacket* packet) {
     return TypedData_Wrap_Struct(klass, &Packet_data_type, ptr);
 }
 
+static VALUE Packet_alloc(VALUE klass) {
+    return Packet_wrap(klass, sfPacket_create());
+}
+
 /* call-seq:
  *   Packet.new -> Packet
  *
@@ -45,8 +49,8 @@ static VALUE Packet_wrap(VALUE klass, sfPacket* packet) {
  *
  * @return [Packet] a new, empty packet
  */
-static VALUE Packet_new(VALUE klass) {
-    return Packet_wrap(klass, sfPacket_create());
+static VALUE Packet_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq: copy -> Packet
@@ -230,8 +234,9 @@ static VALUE Packet_write_string(VALUE self, VALUE rb_value) {
  */
 void Init_Packet(VALUE rb_mSFML) {
     rb_cPacket = rb_define_class_under(rb_mSFML, "Packet", rb_cObject);
+    rb_define_alloc_func(rb_cPacket, Packet_alloc);
 
-    rb_define_singleton_method(rb_cPacket, "new", Packet_new, 0);
+    rb_define_method(rb_cPacket, "initialize", Packet_initialize, 0);
 
     rb_define_method(rb_cPacket, "copy", Packet_copy, 0);
     rb_define_method(rb_cPacket, "append", Packet_append, 1);

data/ext/network/socket_selector.c

@@ -41,6 +41,10 @@ static VALUE SocketSelector_wrap(VALUE klass, sfSocketSelector* handle) {
     return TypedData_Wrap_Struct(klass, &SocketSelector_data_type, ptr);
 }
 
+static VALUE SocketSelector_alloc(VALUE klass) {
+    return SocketSelector_wrap(klass, sfSocketSelector_create());
+}
+
 /* call-seq:
  *   SocketSelector.new -> SocketSelector
  *
@@ -48,8 +52,8 @@ static VALUE SocketSelector_wrap(VALUE klass, sfSocketSelector* handle) {
  *
  * @return [SocketSelector]
  */
-static VALUE SocketSelector_new(VALUE klass) {
-    return SocketSelector_wrap(klass, sfSocketSelector_create());
+static VALUE SocketSelector_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq: copy -> SocketSelector
@@ -189,8 +193,9 @@ static VALUE SocketSelector_udp_socket_ready(VALUE self, VALUE rb_socket) {
  */
 void Init_SocketSelector(VALUE rb_mSFML) {
     rb_cSocketSelector = rb_define_class_under(rb_mSFML, "SocketSelector", rb_cObject);
+    rb_define_alloc_func(rb_cSocketSelector, SocketSelector_alloc);
 
-    rb_define_singleton_method(rb_cSocketSelector, "new", SocketSelector_new, 0);
+    rb_define_method(rb_cSocketSelector, "initialize", SocketSelector_initialize, 0);
 
     rb_define_method(rb_cSocketSelector, "copy", SocketSelector_copy, 0);
     rb_define_method(rb_cSocketSelector, "add", SocketSelector_add, 1);

data/ext/network/tcp_listener.c

@@ -42,6 +42,10 @@ static VALUE TcpListener_wrap(VALUE klass, sfTcpListener* handle) {
     return TypedData_Wrap_Struct(klass, &TcpListener_data_type, ptr);
 }
 
+static VALUE TcpListener_alloc(VALUE klass) {
+    return TcpListener_wrap(klass, sfTcpListener_create());
+}
+
 /* call-seq:
  *   TcpListener.new -> TcpListener
  *
@@ -49,8 +53,8 @@ static VALUE TcpListener_wrap(VALUE klass, sfTcpListener* handle) {
  *
  * @return [TcpListener]
  */
-static VALUE TcpListener_new(VALUE klass) {
-    return TcpListener_wrap(klass, sfTcpListener_create());
+static VALUE TcpListener_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq:
@@ -151,8 +155,9 @@ static VALUE TcpListener_accept(VALUE self) {
  */
 void Init_TcpListener(VALUE rb_mSFML) {
     rb_cTcpListener = rb_define_class_under(rb_mSFML, "TcpListener", rb_cObject);
+    rb_define_alloc_func(rb_cTcpListener, TcpListener_alloc);
 
-    rb_define_singleton_method(rb_cTcpListener, "new", TcpListener_new, 0);
+    rb_define_method(rb_cTcpListener, "initialize", TcpListener_initialize, 0);
     rb_define_singleton_method(rb_cTcpListener, "any_port", TcpListener_any_port, 0);
 
     rb_define_method(rb_cTcpListener, "blocking?", TcpListener_blocking, 0);

data/ext/network/tcp_socket.c

@@ -47,6 +47,10 @@ VALUE tcp_socket_from_handle(sfTcpSocket* socket) {
     return TcpSocket_wrap(rb_cTcpSocket, socket);
 }
 
+static VALUE TcpSocket_alloc(VALUE klass) {
+    return TcpSocket_wrap(klass, sfTcpSocket_create());
+}
+
 /* call-seq:
  *   TcpSocket.new -> TcpSocket
  *
@@ -54,8 +58,8 @@ VALUE tcp_socket_from_handle(sfTcpSocket* socket) {
  *
  * @return [TcpSocket] a new, unconnected socket
  */
-static VALUE TcpSocket_new(VALUE klass) {
-    return TcpSocket_wrap(klass, sfTcpSocket_create());
+static VALUE TcpSocket_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq: blocking? -> true or false
@@ -274,8 +278,9 @@ static VALUE TcpSocket_receive_packet(VALUE self, VALUE rb_packet) {
  */
 void Init_TcpSocket(VALUE rb_mSFML) {
     rb_cTcpSocket = rb_define_class_under(rb_mSFML, "TcpSocket", rb_cObject);
+    rb_define_alloc_func(rb_cTcpSocket, TcpSocket_alloc);
 
-    rb_define_singleton_method(rb_cTcpSocket, "new", TcpSocket_new, 0);
+    rb_define_method(rb_cTcpSocket, "initialize", TcpSocket_initialize, 0);
 
     rb_define_method(rb_cTcpSocket, "blocking?", TcpSocket_blocking, 0);
     rb_define_method(rb_cTcpSocket, "blocking=", TcpSocket_set_blocking, 1);

data/ext/network/udp_socket.c

@@ -42,6 +42,10 @@ static VALUE UdpSocket_wrap(VALUE klass, sfUdpSocket* handle) {
     return TypedData_Wrap_Struct(klass, &UdpSocket_data_type, ptr);
 }
 
+static VALUE UdpSocket_alloc(VALUE klass) {
+    return UdpSocket_wrap(klass, sfUdpSocket_create());
+}
+
 /* call-seq:
  *   UdpSocket.new -> UdpSocket
  *
@@ -49,8 +53,8 @@ static VALUE UdpSocket_wrap(VALUE klass, sfUdpSocket* handle) {
  *
  * @return [UdpSocket] a new, unbound socket
  */
-static VALUE UdpSocket_new(VALUE klass) {
-    return UdpSocket_wrap(klass, sfUdpSocket_create());
+static VALUE UdpSocket_initialize(VALUE self) {
+    return self;
 }
 
 /* call-seq:
@@ -259,8 +263,9 @@ static VALUE UdpSocket_receive_packet(VALUE self, VALUE rb_packet) {
  */
 void Init_UdpSocket(VALUE rb_mSFML) {
     rb_cUdpSocket = rb_define_class_under(rb_mSFML, "UdpSocket", rb_cObject);
+    rb_define_alloc_func(rb_cUdpSocket, UdpSocket_alloc);
 
-    rb_define_singleton_method(rb_cUdpSocket, "new", UdpSocket_new, 0);
+    rb_define_method(rb_cUdpSocket, "initialize", UdpSocket_initialize, 0);
     rb_define_singleton_method(rb_cUdpSocket, "any_port", UdpSocket_any_port, 0);
     rb_define_singleton_method(rb_cUdpSocket, "max_datagram_size", UdpSocket_max_datagram_size, 0);
 

data/ext/system/buffer.c

@@ -20,6 +20,16 @@ static VALUE Buffer_wrap(VALUE klass, sfBuffer* buffer) {
     return TypedData_Wrap_Struct(klass, &Buffer_data_type, buffer);
 }
 
+static VALUE Buffer_alloc(VALUE klass) {
+    sfBuffer* buffer = sfBuffer_create();
+
+    if (buffer == NULL) {
+        rb_raise(rb_eNoMemError, "could not create buffer");
+    }
+
+    return Buffer_wrap(klass, buffer);
+}
+
 /* call-seq:
  *   Buffer.new -> Buffer
  *
@@ -28,16 +38,7 @@ static VALUE Buffer_wrap(VALUE klass, sfBuffer* buffer) {
  * @return [Buffer] a new, empty buffer
  * @raise [NoMemoryError] if the underlying buffer could not be allocated
  */
-static VALUE Buffer_new(VALUE klass) {
-    VALUE self;
-    sfBuffer* buffer = sfBuffer_create();
-
-    if (buffer == NULL) {
-        rb_raise(rb_eNoMemError, "could not create buffer");
-    }
-
-    self = Buffer_wrap(klass, buffer);
-
+static VALUE Buffer_initialize(VALUE self) {
     return self;
 }
 
@@ -86,7 +87,8 @@ static VALUE Buffer_is_empty(VALUE self) {
 void Init_Buffer(VALUE rb_mSFML) {
     rb_cBuffer = rb_define_class_under(rb_mSFML, "Buffer", rb_cObject);
 
-    rb_define_singleton_method(rb_cBuffer, "new", Buffer_new, 0);
+    rb_define_alloc_func(rb_cBuffer, Buffer_alloc);
+    rb_define_method(rb_cBuffer, "initialize", Buffer_initialize, 0);
 
     rb_define_method(rb_cBuffer, "size", Buffer_get_size, 0);
     rb_define_method(rb_cBuffer, "length", Buffer_get_size, 0);