sfml3-rb 0.0.1 → 0.2.2

data/ext/network/ftp.c

@@ -0,0 +1,405 @@
+#include "network/ftp.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/macros.h"
+#include "core/unicode.h"
+#include "network/ip_address.h"
+#include "network/network_enums.h"
+#include "system/time.h"
+
+typedef struct {
+    sfFtp* handle;
+} Ftp;
+
+typedef struct {
+    sfFtpResponse* handle;
+} FtpResponse;
+
+typedef struct {
+    sfFtpDirectoryResponse* handle;
+} FtpDirectoryResponse;
+
+typedef struct {
+    sfFtpListingResponse* handle;
+} FtpListingResponse;
+
+static VALUE rb_cFtp;
+static VALUE rb_cFtpResponse;
+static VALUE rb_cFtpDirectoryResponse;
+static VALUE rb_cFtpListingResponse;
+
+static void Ftp_free(void* ptr) {
+    Ftp* ftp = ptr;
+
+    sfFtp_destroy(ftp->handle);
+    free(ftp);
+}
+
+static void FtpResponse_free(void* ptr) {
+    FtpResponse* response = ptr;
+
+    sfFtpResponse_destroy(response->handle);
+    free(response);
+}
+
+static void FtpDirectoryResponse_free(void* ptr) {
+    FtpDirectoryResponse* response = ptr;
+
+    sfFtpDirectoryResponse_destroy(response->handle);
+    free(response);
+}
+
+static void FtpListingResponse_free(void* ptr) {
+    FtpListingResponse* response = ptr;
+
+    sfFtpListingResponse_destroy(response->handle);
+    free(response);
+}
+
+static const rb_data_type_t Ftp_data_type = {
+    .wrap_struct_name = "SFML::Ftp",
+    .function = {.dmark = NULL, .dfree = Ftp_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static const rb_data_type_t FtpResponse_data_type = {
+    .wrap_struct_name = "SFML::FtpResponse",
+    .function = {.dmark = NULL, .dfree = FtpResponse_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static const rb_data_type_t FtpDirectoryResponse_data_type = {
+    .wrap_struct_name = "SFML::FtpDirectoryResponse",
+    .function = {.dmark = NULL, .dfree = FtpDirectoryResponse_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static const rb_data_type_t FtpListingResponse_data_type = {
+    .wrap_struct_name = "SFML::FtpListingResponse",
+    .function = {.dmark = NULL, .dfree = FtpListingResponse_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Ftp_wrap(sfFtp* handle) {
+    Ftp* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create FTP client");
+    }
+
+    ptr = malloc(sizeof(Ftp));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(rb_cFtp, &Ftp_data_type, ptr);
+}
+
+static VALUE FtpResponse_wrap(sfFtpResponse* handle) {
+    FtpResponse* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "FTP request failed");
+    }
+
+    ptr = malloc(sizeof(FtpResponse));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(rb_cFtpResponse, &FtpResponse_data_type, ptr);
+}
+
+static VALUE FtpDirectoryResponse_wrap(sfFtpDirectoryResponse* handle) {
+    FtpDirectoryResponse* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "FTP request failed");
+    }
+
+    ptr = malloc(sizeof(FtpDirectoryResponse));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(rb_cFtpDirectoryResponse, &FtpDirectoryResponse_data_type, ptr);
+}
+
+static VALUE FtpListingResponse_wrap(sfFtpListingResponse* handle) {
+    FtpListingResponse* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "FTP request failed");
+    }
+
+    ptr = malloc(sizeof(FtpListingResponse));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(rb_cFtpListingResponse, &FtpListingResponse_data_type, ptr);
+}
+
+static VALUE Ftp_new(VALUE klass) {
+    return Ftp_wrap(sfFtp_create());
+}
+
+static VALUE Ftp_connect(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_address, rb_port, rb_timeout;
+    sfTime timeout = sfTime_Zero;
+    unsigned short port = 21;
+
+    rb_scan_args(argc, argv, "12", &rb_address, &rb_port, &rb_timeout);
+
+    if (!NIL_P(rb_port)) {
+        port = (unsigned short)NUM2INT(rb_port);
+    }
+
+    if (!NIL_P(rb_timeout)) {
+        timeout = time_from_rb(rb_timeout);
+    }
+
+    return FtpResponse_wrap(sfFtp_connect(
+        Get_Ftp_Struct(self), ip_address_from_rb(rb_address, sfIpAddress_None), port, timeout));
+}
+
+static VALUE Ftp_login_anonymous(VALUE self) {
+    return FtpResponse_wrap(sfFtp_loginAnonymous(Get_Ftp_Struct(self)));
+}
+
+static VALUE Ftp_login(VALUE self, VALUE rb_name, VALUE rb_password) {
+    return FtpResponse_wrap(
+        sfFtp_login(Get_Ftp_Struct(self), StringValueCStr(rb_name), StringValueCStr(rb_password)));
+}
+
+static VALUE Ftp_disconnect(VALUE self) {
+    return FtpResponse_wrap(sfFtp_disconnect(Get_Ftp_Struct(self)));
+}
+
+static VALUE Ftp_keep_alive(VALUE self) {
+    return FtpResponse_wrap(sfFtp_keepAlive(Get_Ftp_Struct(self)));
+}
+
+static VALUE Ftp_working_directory(VALUE self) {
+    return FtpDirectoryResponse_wrap(sfFtp_getWorkingDirectory(Get_Ftp_Struct(self)));
+}
+
+static VALUE Ftp_directory_listing(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_directory;
+
+    rb_scan_args(argc, argv, "01", &rb_directory);
+
+    return FtpListingResponse_wrap(sfFtp_getDirectoryListing(
+        Get_Ftp_Struct(self), NIL_P(rb_directory) ? NULL : StringValueCStr(rb_directory)));
+}
+
+static VALUE Ftp_change_directory(VALUE self, VALUE rb_directory) {
+    return FtpResponse_wrap(
+        sfFtp_changeDirectory(Get_Ftp_Struct(self), StringValueCStr(rb_directory)));
+}
+
+static VALUE Ftp_parent_directory(VALUE self) {
+    return FtpResponse_wrap(sfFtp_parentDirectory(Get_Ftp_Struct(self)));
+}
+
+static VALUE Ftp_create_directory(VALUE self, VALUE rb_name) {
+    return FtpResponse_wrap(sfFtp_createDirectory(Get_Ftp_Struct(self), StringValueCStr(rb_name)));
+}
+
+static VALUE Ftp_delete_directory(VALUE self, VALUE rb_name) {
+    return FtpResponse_wrap(sfFtp_deleteDirectory(Get_Ftp_Struct(self), StringValueCStr(rb_name)));
+}
+
+static VALUE Ftp_rename_file(VALUE self, VALUE rb_file, VALUE rb_new_name) {
+    return FtpResponse_wrap(sfFtp_renameFile(Get_Ftp_Struct(self), StringValueCStr(rb_file),
+                                             StringValueCStr(rb_new_name)));
+}
+
+static VALUE Ftp_delete_file(VALUE self, VALUE rb_name) {
+    return FtpResponse_wrap(sfFtp_deleteFile(Get_Ftp_Struct(self), StringValueCStr(rb_name)));
+}
+
+static VALUE Ftp_download(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_remote, rb_local, rb_mode;
+    sfFtpTransferMode mode = sfFtpBinary;
+
+    rb_scan_args(argc, argv, "21", &rb_remote, &rb_local, &rb_mode);
+
+    if (!NIL_P(rb_mode)) {
+        mode = ftp_transfer_mode_from_rb(rb_mode);
+    }
+
+    return FtpResponse_wrap(sfFtp_download(Get_Ftp_Struct(self), StringValueCStr(rb_remote),
+                                           StringValueCStr(rb_local), mode));
+}
+
+static VALUE Ftp_upload(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_local, rb_remote, rb_mode, rb_append;
+    sfFtpTransferMode mode = sfFtpBinary;
+    bool append = false;
+
+    rb_scan_args(argc, argv, "22", &rb_local, &rb_remote, &rb_mode, &rb_append);
+
+    if (!NIL_P(rb_mode)) {
+        mode = ftp_transfer_mode_from_rb(rb_mode);
+    }
+
+    if (!NIL_P(rb_append)) {
+        append = RTEST(rb_append);
+    }
+
+    return FtpResponse_wrap(sfFtp_upload(Get_Ftp_Struct(self), StringValueCStr(rb_local),
+                                         StringValueCStr(rb_remote), mode, append));
+}
+
+static VALUE Ftp_send_command(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_command, rb_parameter;
+
+    rb_scan_args(argc, argv, "11", &rb_command, &rb_parameter);
+
+    return FtpResponse_wrap(
+        sfFtp_sendCommand(Get_Ftp_Struct(self), StringValueCStr(rb_command),
+                          NIL_P(rb_parameter) ? NULL : StringValueCStr(rb_parameter)));
+}
+
+static VALUE FtpResponse_ok(VALUE self) {
+    return BOOL2RB(sfFtpResponse_isOk(Get_FtpResponse_Struct(self)));
+}
+
+static VALUE FtpResponse_status(VALUE self) {
+    return INT2NUM(sfFtpResponse_getStatus(Get_FtpResponse_Struct(self)));
+}
+
+static VALUE FtpResponse_status_name(VALUE self) {
+    return ID2SYM(
+        rb_intern(ftp_status_name(sfFtpResponse_getStatus(Get_FtpResponse_Struct(self)))));
+}
+
+static VALUE FtpResponse_message(VALUE self) {
+    return rb_str_new_cstr(sfFtpResponse_getMessage(Get_FtpResponse_Struct(self)));
+}
+
+static VALUE FtpDirectoryResponse_ok(VALUE self) {
+    return BOOL2RB(sfFtpDirectoryResponse_isOk(Get_FtpDirectoryResponse_Struct(self)));
+}
+
+static VALUE FtpDirectoryResponse_status(VALUE self) {
+    return INT2NUM(sfFtpDirectoryResponse_getStatus(Get_FtpDirectoryResponse_Struct(self)));
+}
+
+static VALUE FtpDirectoryResponse_status_name(VALUE self) {
+    return ID2SYM(rb_intern(
+        ftp_status_name(sfFtpDirectoryResponse_getStatus(Get_FtpDirectoryResponse_Struct(self)))));
+}
+
+static VALUE FtpDirectoryResponse_message(VALUE self) {
+    return rb_str_new_cstr(
+        sfFtpDirectoryResponse_getMessage(Get_FtpDirectoryResponse_Struct(self)));
+}
+
+/* Through the UTF-32 entry point, so a path with non-ASCII characters survives
+   the trip; the plain getter re-encodes it through the C locale. */
+static VALUE FtpDirectoryResponse_directory(VALUE self) {
+    return utf32_to_rb(
+        sfFtpDirectoryResponse_getDirectoryUnicode(Get_FtpDirectoryResponse_Struct(self)));
+}
+
+static VALUE FtpListingResponse_ok(VALUE self) {
+    return BOOL2RB(sfFtpListingResponse_isOk(Get_FtpListingResponse_Struct(self)));
+}
+
+static VALUE FtpListingResponse_status(VALUE self) {
+    return INT2NUM(sfFtpListingResponse_getStatus(Get_FtpListingResponse_Struct(self)));
+}
+
+static VALUE FtpListingResponse_status_name(VALUE self) {
+    return ID2SYM(rb_intern(
+        ftp_status_name(sfFtpListingResponse_getStatus(Get_FtpListingResponse_Struct(self)))));
+}
+
+static VALUE FtpListingResponse_message(VALUE self) {
+    return rb_str_new_cstr(sfFtpListingResponse_getMessage(Get_FtpListingResponse_Struct(self)));
+}
+
+static VALUE FtpListingResponse_count(VALUE self) {
+    return SIZET2NUM(sfFtpListingResponse_getCount(Get_FtpListingResponse_Struct(self)));
+}
+
+static VALUE FtpListingResponse_name(VALUE self, VALUE rb_index) {
+    return rb_str_new_cstr(sfFtpListingResponse_getName(Get_FtpListingResponse_Struct(self),
+                                                        (size_t)NUM2SIZET(rb_index)));
+}
+
+void Init_Ftp(VALUE rb_module) {
+    rb_cFtp = rb_define_class_under(rb_module, "Ftp", rb_cObject);
+    rb_cFtpResponse = rb_define_class_under(rb_module, "FtpResponse", rb_cObject);
+    rb_cFtpDirectoryResponse = rb_define_class_under(rb_module, "FtpDirectoryResponse", rb_cObject);
+    rb_cFtpListingResponse = rb_define_class_under(rb_module, "FtpListingResponse", rb_cObject);
+
+    rb_define_singleton_method(rb_cFtp, "new", Ftp_new, 0);
+
+    rb_define_method(rb_cFtp, "connect", Ftp_connect, -1);
+    rb_define_method(rb_cFtp, "login_anonymous", Ftp_login_anonymous, 0);
+    rb_define_method(rb_cFtp, "login", Ftp_login, 2);
+    rb_define_method(rb_cFtp, "disconnect", Ftp_disconnect, 0);
+    rb_define_method(rb_cFtp, "keep_alive", Ftp_keep_alive, 0);
+    rb_define_method(rb_cFtp, "working_directory", Ftp_working_directory, 0);
+    rb_define_method(rb_cFtp, "directory_listing", Ftp_directory_listing, -1);
+    rb_define_method(rb_cFtp, "change_directory", Ftp_change_directory, 1);
+    rb_define_method(rb_cFtp, "parent_directory", Ftp_parent_directory, 0);
+    rb_define_method(rb_cFtp, "create_directory", Ftp_create_directory, 1);
+    rb_define_method(rb_cFtp, "delete_directory", Ftp_delete_directory, 1);
+    rb_define_method(rb_cFtp, "rename_file", Ftp_rename_file, 2);
+    rb_define_method(rb_cFtp, "delete_file", Ftp_delete_file, 1);
+    rb_define_method(rb_cFtp, "download", Ftp_download, -1);
+    rb_define_method(rb_cFtp, "upload", Ftp_upload, -1);
+    rb_define_method(rb_cFtp, "send_command", Ftp_send_command, -1);
+
+    rb_define_method(rb_cFtpResponse, "ok?", FtpResponse_ok, 0);
+    rb_define_method(rb_cFtpResponse, "status", FtpResponse_status, 0);
+    rb_define_method(rb_cFtpResponse, "status_name", FtpResponse_status_name, 0);
+    rb_define_method(rb_cFtpResponse, "message", FtpResponse_message, 0);
+
+    rb_define_method(rb_cFtpDirectoryResponse, "ok?", FtpDirectoryResponse_ok, 0);
+    rb_define_method(rb_cFtpDirectoryResponse, "status", FtpDirectoryResponse_status, 0);
+    rb_define_method(rb_cFtpDirectoryResponse, "status_name", FtpDirectoryResponse_status_name, 0);
+    rb_define_method(rb_cFtpDirectoryResponse, "message", FtpDirectoryResponse_message, 0);
+    rb_define_method(rb_cFtpDirectoryResponse, "directory", FtpDirectoryResponse_directory, 0);
+
+    rb_define_method(rb_cFtpListingResponse, "ok?", FtpListingResponse_ok, 0);
+    rb_define_method(rb_cFtpListingResponse, "status", FtpListingResponse_status, 0);
+    rb_define_method(rb_cFtpListingResponse, "status_name", FtpListingResponse_status_name, 0);
+    rb_define_method(rb_cFtpListingResponse, "message", FtpListingResponse_message, 0);
+    rb_define_method(rb_cFtpListingResponse, "count", FtpListingResponse_count, 0);
+    rb_define_method(rb_cFtpListingResponse, "name", FtpListingResponse_name, 1);
+}
+
+VALUE Get_Klass_Ftp(void) {
+    return rb_cFtp;
+}
+
+VALUE Get_Klass_FtpResponse(void) {
+    return rb_cFtpResponse;
+}
+
+VALUE Get_Klass_FtpDirectoryResponse(void) {
+    return rb_cFtpDirectoryResponse;
+}
+
+VALUE Get_Klass_FtpListingResponse(void) {
+    return rb_cFtpListingResponse;
+}
+
+void* Get_Ftp_Struct(VALUE self) {
+    Ftp* ptr;
+    TypedData_Get_Struct(self, Ftp, &Ftp_data_type, ptr);
+    return ptr->handle;
+}
+
+void* Get_FtpResponse_Struct(VALUE self) {
+    FtpResponse* ptr;
+    TypedData_Get_Struct(self, FtpResponse, &FtpResponse_data_type, ptr);
+    return ptr->handle;
+}
+
+void* Get_FtpDirectoryResponse_Struct(VALUE self) {
+    FtpDirectoryResponse* ptr;
+    TypedData_Get_Struct(self, FtpDirectoryResponse, &FtpDirectoryResponse_data_type, ptr);
+    return ptr->handle;
+}
+
+void* Get_FtpListingResponse_Struct(VALUE self) {
+    FtpListingResponse* ptr;
+    TypedData_Get_Struct(self, FtpListingResponse, &FtpListingResponse_data_type, ptr);
+    return ptr->handle;
+}

data/ext/network/ftp.h

@@ -0,0 +1,20 @@
+#ifndef SFML_RB_NETWORK_FTP_H
+#define SFML_RB_NETWORK_FTP_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Ftp(VALUE rb_module);
+
+VALUE Get_Klass_Ftp(void);
+VALUE Get_Klass_FtpResponse(void);
+VALUE Get_Klass_FtpDirectoryResponse(void);
+VALUE Get_Klass_FtpListingResponse(void);
+
+void *Get_Ftp_Struct(VALUE self);
+void *Get_FtpResponse_Struct(VALUE self);
+void *Get_FtpDirectoryResponse_Struct(VALUE self);
+void *Get_FtpListingResponse_Struct(VALUE self);
+
+#endif //SFML_RB_NETWORK_FTP_H

data/ext/network/http.c

@@ -0,0 +1,243 @@
+#include "network/http.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/macros.h"
+#include "network/network_enums.h"
+#include "system/time.h"
+
+typedef struct {
+    sfHttp *handle;
+} Http;
+
+typedef struct {
+    sfHttpRequest *handle;
+} HttpRequest;
+
+typedef struct {
+    sfHttpResponse *handle;
+} HttpResponse;
+
+static VALUE rb_cHttp;
+static VALUE rb_cHttpRequest;
+static VALUE rb_cHttpResponse;
+
+static void Http_free(void *ptr) {
+    Http *http = ptr;
+
+    sfHttp_destroy(http->handle);
+    free(http);
+}
+
+static void HttpRequest_free(void *ptr) {
+    HttpRequest *request = ptr;
+
+    sfHttpRequest_destroy(request->handle);
+    free(request);
+}
+
+static void HttpResponse_free(void *ptr) {
+    HttpResponse *response = ptr;
+
+    sfHttpResponse_destroy(response->handle);
+    free(response);
+}
+
+static const rb_data_type_t Http_data_type = {
+    .wrap_struct_name = "SFML::Http",
+    .function = {.dmark = NULL, .dfree = Http_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static const rb_data_type_t HttpRequest_data_type = {
+    .wrap_struct_name = "SFML::HttpRequest",
+    .function = {.dmark = NULL, .dfree = HttpRequest_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static const rb_data_type_t HttpResponse_data_type = {
+    .wrap_struct_name = "SFML::HttpResponse",
+    .function = {.dmark = NULL, .dfree = HttpResponse_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Http_wrap(VALUE klass, sfHttp *handle) {
+    Http *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create HTTP client");
+    }
+
+    ptr = malloc(sizeof(Http));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &Http_data_type, ptr);
+}
+
+static VALUE HttpRequest_wrap(VALUE klass, sfHttpRequest *handle) {
+    HttpRequest *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create HTTP request");
+    }
+
+    ptr = malloc(sizeof(HttpRequest));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &HttpRequest_data_type, ptr);
+}
+
+static VALUE HttpResponse_wrap(sfHttpResponse *handle) {
+    HttpResponse *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "HTTP request failed");
+    }
+
+    ptr = malloc(sizeof(HttpResponse));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(rb_cHttpResponse, &HttpResponse_data_type, ptr);
+}
+
+static VALUE Http_new(VALUE klass) {
+    return Http_wrap(klass, sfHttp_create());
+}
+
+static VALUE Http_set_host(VALUE self, VALUE rb_host, VALUE rb_port) {
+    sfHttp_setHost(Get_Http_Struct(self), StringValueCStr(rb_host), (unsigned short) NUM2INT(rb_port));
+    return self;
+}
+
+static VALUE Http_send_request(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_request, rb_timeout;
+    sfTime timeout = sfTime_Zero;
+
+    rb_scan_args(argc, argv, "11", &rb_request, &rb_timeout);
+
+    if (!rb_obj_is_kind_of(rb_request, rb_cHttpRequest)) {
+        rb_raise(rb_eTypeError, "expected an SFML::HttpRequest");
+    }
+
+    if (!NIL_P(rb_timeout)) {
+        timeout = time_from_rb(rb_timeout);
+    }
+
+    return HttpResponse_wrap(
+        sfHttp_sendRequest(Get_Http_Struct(self), Get_HttpRequest_Struct(rb_request), timeout));
+}
+
+static VALUE HttpRequest_new(VALUE klass) {
+    return HttpRequest_wrap(klass, sfHttpRequest_create());
+}
+
+static VALUE HttpRequest_set_field(VALUE self, VALUE rb_field, VALUE rb_value) {
+    sfHttpRequest_setField(Get_HttpRequest_Struct(self), StringValueCStr(rb_field),
+                           StringValueCStr(rb_value));
+    return rb_value;
+}
+
+static VALUE HttpRequest_set_method(VALUE self, VALUE rb_method) {
+    sfHttpRequest_setMethod(Get_HttpRequest_Struct(self), http_method_from_rb(rb_method));
+    return rb_method;
+}
+
+static VALUE HttpRequest_set_uri(VALUE self, VALUE rb_uri) {
+    sfHttpRequest_setUri(Get_HttpRequest_Struct(self), StringValueCStr(rb_uri));
+    return rb_uri;
+}
+
+static VALUE HttpRequest_set_http_version(VALUE self, VALUE rb_major, VALUE rb_minor) {
+    sfHttpRequest_setHttpVersion(Get_HttpRequest_Struct(self), (unsigned int) NUM2INT(rb_major),
+                                 (unsigned int) NUM2INT(rb_minor));
+
+    return rb_ary_new_from_args(2, rb_major, rb_minor);
+}
+
+static VALUE HttpRequest_set_body(VALUE self, VALUE rb_body) {
+    sfHttpRequest_setBody(Get_HttpRequest_Struct(self), StringValueCStr(rb_body));
+    return rb_body;
+}
+
+static VALUE HttpResponse_field(VALUE self, VALUE rb_field) {
+    const char *field = sfHttpResponse_getField(Get_HttpResponse_Struct(self),
+                                                StringValueCStr(rb_field));
+
+    return field != NULL ? rb_str_new_cstr(field) : Qnil;
+}
+
+static VALUE HttpResponse_status(VALUE self) {
+    return INT2NUM(sfHttpResponse_getStatus(Get_HttpResponse_Struct(self)));
+}
+
+static VALUE HttpResponse_status_name(VALUE self) {
+    return ID2SYM(rb_intern(http_status_name(sfHttpResponse_getStatus(Get_HttpResponse_Struct(self)))));
+}
+
+static VALUE HttpResponse_major_version(VALUE self) {
+    return UINT2NUM(sfHttpResponse_getMajorVersion(Get_HttpResponse_Struct(self)));
+}
+
+static VALUE HttpResponse_minor_version(VALUE self) {
+    return UINT2NUM(sfHttpResponse_getMinorVersion(Get_HttpResponse_Struct(self)));
+}
+
+static VALUE HttpResponse_body(VALUE self) {
+    return rb_str_new_cstr(sfHttpResponse_getBody(Get_HttpResponse_Struct(self)));
+}
+
+void Init_Http(VALUE rb_module) {
+    rb_cHttp = rb_define_class_under(rb_module, "Http", rb_cObject);
+    rb_cHttpRequest = rb_define_class_under(rb_module, "HttpRequest", rb_cObject);
+    rb_cHttpResponse = rb_define_class_under(rb_module, "HttpResponse", rb_cObject);
+
+    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, "set_host", Http_set_host, 2);
+    rb_define_method(rb_cHttp, "send_request", Http_send_request, -1);
+
+    rb_define_method(rb_cHttpRequest, "set_field", HttpRequest_set_field, 2);
+    rb_define_method(rb_cHttpRequest, "method=", HttpRequest_set_method, 1);
+    rb_define_method(rb_cHttpRequest, "uri=", HttpRequest_set_uri, 1);
+    rb_define_method(rb_cHttpRequest, "set_http_version", HttpRequest_set_http_version, 2);
+    rb_define_method(rb_cHttpRequest, "body=", HttpRequest_set_body, 1);
+
+    rb_define_method(rb_cHttpResponse, "field", HttpResponse_field, 1);
+    rb_define_method(rb_cHttpResponse, "status", HttpResponse_status, 0);
+    rb_define_method(rb_cHttpResponse, "status_name", HttpResponse_status_name, 0);
+    rb_define_method(rb_cHttpResponse, "major_version", HttpResponse_major_version, 0);
+    rb_define_method(rb_cHttpResponse, "minor_version", HttpResponse_minor_version, 0);
+    rb_define_method(rb_cHttpResponse, "body", HttpResponse_body, 0);
+}
+
+VALUE Get_Klass_Http(void) {
+    return rb_cHttp;
+}
+
+VALUE Get_Klass_HttpRequest(void) {
+    return rb_cHttpRequest;
+}
+
+VALUE Get_Klass_HttpResponse(void) {
+    return rb_cHttpResponse;
+}
+
+void *Get_Http_Struct(VALUE self) {
+    Http *ptr;
+    TypedData_Get_Struct(self, Http, &Http_data_type, ptr);
+    return ptr->handle;
+}
+
+void *Get_HttpRequest_Struct(VALUE self) {
+    HttpRequest *ptr;
+    TypedData_Get_Struct(self, HttpRequest, &HttpRequest_data_type, ptr);
+    return ptr->handle;
+}
+
+void *Get_HttpResponse_Struct(VALUE self) {
+    HttpResponse *ptr;
+    TypedData_Get_Struct(self, HttpResponse, &HttpResponse_data_type, ptr);
+    return ptr->handle;
+}

data/ext/network/http.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_NETWORK_HTTP_H
+#define SFML_RB_NETWORK_HTTP_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Http(VALUE rb_module);
+
+VALUE Get_Klass_Http(void);
+VALUE Get_Klass_HttpRequest(void);
+VALUE Get_Klass_HttpResponse(void);
+
+void *Get_Http_Struct(VALUE self);
+void *Get_HttpRequest_Struct(VALUE self);
+void *Get_HttpResponse_Struct(VALUE self);
+
+#endif //SFML_RB_NETWORK_HTTP_H