sfml3-rb 0.2.2 → 0.3.1

data/ext/network/http.c

@@ -8,37 +8,37 @@
 #include "system/time.h"
 
 typedef struct {
-    sfHttp *handle;
+    sfHttp* handle;
 } Http;
 
 typedef struct {
-    sfHttpRequest *handle;
+    sfHttpRequest* handle;
 } HttpRequest;
 
 typedef struct {
-    sfHttpResponse *handle;
+    sfHttpResponse* handle;
 } HttpResponse;
 
 static VALUE rb_cHttp;
 static VALUE rb_cHttpRequest;
 static VALUE rb_cHttpResponse;
 
-static void Http_free(void *ptr) {
-    Http *http = ptr;
+static void Http_free(void* ptr) {
+    Http* http = ptr;
 
     sfHttp_destroy(http->handle);
     free(http);
 }
 
-static void HttpRequest_free(void *ptr) {
-    HttpRequest *request = ptr;
+static void HttpRequest_free(void* ptr) {
+    HttpRequest* request = ptr;
 
     sfHttpRequest_destroy(request->handle);
     free(request);
 }
 
-static void HttpResponse_free(void *ptr) {
-    HttpResponse *response = ptr;
+static void HttpResponse_free(void* ptr) {
+    HttpResponse* response = ptr;
 
     sfHttpResponse_destroy(response->handle);
     free(response);
@@ -47,23 +47,20 @@ static void HttpResponse_free(void *ptr) {
 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
-};
+    .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
-};
+    .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
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE Http_wrap(VALUE klass, sfHttp *handle) {
-    Http *ptr;
+static VALUE Http_wrap(VALUE klass, sfHttp* handle) {
+    Http* ptr;
 
     if (handle == NULL) {
         rb_raise(rb_eRuntimeError, "failed to create HTTP client");
@@ -75,8 +72,8 @@ static VALUE Http_wrap(VALUE klass, sfHttp *handle) {
     return TypedData_Wrap_Struct(klass, &Http_data_type, ptr);
 }
 
-static VALUE HttpRequest_wrap(VALUE klass, sfHttpRequest *handle) {
-    HttpRequest *ptr;
+static VALUE HttpRequest_wrap(VALUE klass, sfHttpRequest* handle) {
+    HttpRequest* ptr;
 
     if (handle == NULL) {
         rb_raise(rb_eRuntimeError, "failed to create HTTP request");
@@ -88,8 +85,8 @@ static VALUE HttpRequest_wrap(VALUE klass, sfHttpRequest *handle) {
     return TypedData_Wrap_Struct(klass, &HttpRequest_data_type, ptr);
 }
 
-static VALUE HttpResponse_wrap(sfHttpResponse *handle) {
-    HttpResponse *ptr;
+static VALUE HttpResponse_wrap(sfHttpResponse* handle) {
+    HttpResponse* ptr;
 
     if (handle == NULL) {
         rb_raise(rb_eRuntimeError, "HTTP request failed");
@@ -101,16 +98,56 @@ static VALUE HttpResponse_wrap(sfHttpResponse *handle) {
     return TypedData_Wrap_Struct(rb_cHttpResponse, &HttpResponse_data_type, ptr);
 }
 
-static VALUE Http_new(VALUE klass) {
+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
+ *
+ * Creates a new HTTP client with no host set.
+ *
+ * @return [Http]
+ */
+static VALUE Http_initialize(VALUE self) {
+    return self;
+}
+
+/* call-seq:
+ *   set_host(host, port = 0) -> self
+ *
+ * Sets the target host of subsequent requests. +port+ of 0 means the
+ * standard port for the scheme (80 for HTTP, 443 for HTTPS) is used;
+ * +host+ may include a scheme, e.g. +"https://example.com"+.
+ *
+ * @return [self]
+ */
 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));
+    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) {
+/* call-seq:
+ *   send_request(request, timeout = Time.zero) -> HttpResponse
+ *
+ * Sends +request+ to the host set with #set_host, blocking until the
+ * response arrives or +timeout+ elapses.
+ *
+ * @return [HttpResponse]
+ * @raise [TypeError] if +request+ is not an SFML::HttpRequest
+ */
+static VALUE Http_send_request(int argc, VALUE* argv, VALUE self) {
     VALUE rb_request, rb_timeout;
     sfTime timeout = sfTime_Zero;
 
@@ -128,72 +165,170 @@ static VALUE Http_send_request(int argc, VALUE *argv, VALUE self) {
         sfHttp_sendRequest(Get_Http_Struct(self), Get_HttpRequest_Struct(rb_request), timeout));
 }
 
-static VALUE HttpRequest_new(VALUE klass) {
-    return HttpRequest_wrap(klass, sfHttpRequest_create());
+/* call-seq:
+ *   HttpRequest.new -> HttpRequest
+ *
+ * Creates a new HTTP request.
+ *
+ * @return [HttpRequest] a new request, defaulting to a GET of +"/"+ over
+ *   HTTP/1.0 with no fields or body
+ */
+static VALUE HttpRequest_initialize(VALUE self) {
+    return self;
 }
 
+/* call-seq:
+ *   set_field(field, value) -> value
+ *
+ * Sets the value of a header field, e.g. +"Content-Type"+. Field names are
+ * case-insensitive. A few fields (Content-Length, Connection, User-Agent,
+ * Host) are managed automatically and overwritten before sending.
+ *
+ * @return [String] +value+
+ */
 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;
 }
 
+/* call-seq:
+ *   method=(value) -> value
+ *
+ * +value+ is an HttpMethod name or value.
+ *
+ * @return [Symbol, Integer] +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;
 }
 
+/* call-seq:
+ *   uri=(value) -> value
+ *
+ * Sets the request URI, e.g. +"/index.html"+.
+ *
+ * @return [String] +value+
+ */
 static VALUE HttpRequest_set_uri(VALUE self, VALUE rb_uri) {
     sfHttpRequest_setUri(Get_HttpRequest_Struct(self), StringValueCStr(rb_uri));
     return rb_uri;
 }
 
+/* call-seq:
+ *   set_http_version(major, minor) -> [major, minor]
+ *
+ * Sets the HTTP protocol version used by the request.
+ *
+ * @return [Array(Integer, Integer)] +[major, minor]+
+ */
 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));
+    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);
 }
 
+/* call-seq:
+ *   body=(value) -> value
+ *
+ * Sets the request body, used by POST/PUT requests; ignored for GET/HEAD.
+ *
+ * @return [String] +value+
+ */
 static VALUE HttpRequest_set_body(VALUE self, VALUE rb_body) {
     sfHttpRequest_setBody(Get_HttpRequest_Struct(self), StringValueCStr(rb_body));
     return rb_body;
 }
 
+/* call-seq:
+ *   field(name) -> String or nil
+ *
+ * Returns the value of the response header field named +name+.
+ *
+ * @return [String, nil] the value of response header field +name+
+ *   (case-insensitive), or +nil+ if it wasn't sent
+ */
 static VALUE HttpResponse_field(VALUE self, VALUE rb_field) {
-    const char *field = sfHttpResponse_getField(Get_HttpResponse_Struct(self),
-                                                StringValueCStr(rb_field));
+    const char* field =
+        sfHttpResponse_getField(Get_HttpResponse_Struct(self), StringValueCStr(rb_field));
 
     return field != NULL ? rb_str_new_cstr(field) : Qnil;
 }
 
+/* call-seq: status -> Integer
+ *
+ * Returns the numeric HTTP status code.
+ *
+ * @return [Integer] the raw HTTP status code
+ */
 static VALUE HttpResponse_status(VALUE self) {
     return INT2NUM(sfHttpResponse_getStatus(Get_HttpResponse_Struct(self)));
 }
 
+/* call-seq: status_name -> Symbol
+ *
+ * Returns the status as an HttpStatus name.
+ *
+ * @return [Symbol] an HttpStatus name for #status
+ */
 static VALUE HttpResponse_status_name(VALUE self) {
-    return ID2SYM(rb_intern(http_status_name(sfHttpResponse_getStatus(Get_HttpResponse_Struct(self)))));
+    return ID2SYM(
+        rb_intern(http_status_name(sfHttpResponse_getStatus(Get_HttpResponse_Struct(self)))));
 }
 
+/* call-seq: major_version -> Integer
+ *
+ * Returns the major component of the HTTP protocol version.
+ *
+ * @return [Integer] the major version of the HTTP protocol used by the server
+ */
 static VALUE HttpResponse_major_version(VALUE self) {
     return UINT2NUM(sfHttpResponse_getMajorVersion(Get_HttpResponse_Struct(self)));
 }
 
+/* call-seq: minor_version -> Integer
+ *
+ * Returns the minor component of the HTTP protocol version.
+ *
+ * @return [Integer] the minor version of the HTTP protocol used by the server
+ */
 static VALUE HttpResponse_minor_version(VALUE self) {
     return UINT2NUM(sfHttpResponse_getMinorVersion(Get_HttpResponse_Struct(self)));
 }
 
+/* call-seq: body -> String
+ *
+ * Returns the body of the response.
+ *
+ * @return [String] the body of the response, possibly an error message
+ *   when the server sent something other than valid HTML
+ */
 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);
+/* Document-class: SFML::Http
+ * A basic HTTP client for performing requests against one host at a time
+ * (set with #set_host).
+ */
+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_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);
@@ -224,20 +359,20 @@ VALUE Get_Klass_HttpResponse(void) {
     return rb_cHttpResponse;
 }
 
-void *Get_Http_Struct(VALUE self) {
-    Http *ptr;
+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;
+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;
+void* Get_HttpResponse_Struct(VALUE self) {
+    HttpResponse* ptr;
     TypedData_Get_Struct(self, HttpResponse, &HttpResponse_data_type, ptr);
     return ptr->handle;
 }

data/ext/network/ip_address.c

@@ -13,60 +13,117 @@ typedef struct {
 
 static VALUE rb_cIpAddress;
 
-static void IpAddress_free(void *ptr) {
+static void IpAddress_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t IpAddress_data_type = {
     .wrap_struct_name = "SFML::IpAddress",
     .function = {.dmark = NULL, .dfree = IpAddress_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
 VALUE ip_address_to_rb(sfIpAddress address) {
-    IpAddress *ptr = malloc(sizeof(IpAddress));
+    IpAddress* ptr = malloc(sizeof(IpAddress));
 
     ptr->address = address;
 
     return TypedData_Wrap_Struct(rb_cIpAddress, &IpAddress_data_type, ptr);
 }
 
+/* call-seq:
+ *   IpAddress.from_string(address) -> IpAddress
+ *
+ * Builds an address from a string, which may be a dotted decimal
+ * (+"192.168.1.1"+) or a network name (+"localhost"+).
+ *
+ * @return [IpAddress]
+ */
 static VALUE IpAddress_from_string(VALUE klass, VALUE rb_address) {
     return ip_address_to_rb(sfIpAddress_fromString(StringValueCStr(rb_address)));
 }
 
+/* call-seq:
+ *   IpAddress.from_bytes(byte0, byte1, byte2, byte3) -> IpAddress
+ *
+ * Builds an address from its four decimal byte components (e.g.
+ * +192, 168, 1, 1+).
+ *
+ * @return [IpAddress]
+ */
 static VALUE IpAddress_from_bytes(VALUE klass, VALUE rb0, VALUE rb1, VALUE rb2, VALUE rb3) {
-    return ip_address_to_rb(sfIpAddress_fromBytes((uint8_t) NUM2INT(rb0), (uint8_t) NUM2INT(rb1),
-                                                  (uint8_t) NUM2INT(rb2), (uint8_t) NUM2INT(rb3)));
+    return ip_address_to_rb(sfIpAddress_fromBytes((uint8_t)NUM2INT(rb0), (uint8_t)NUM2INT(rb1),
+                                                  (uint8_t)NUM2INT(rb2), (uint8_t)NUM2INT(rb3)));
 }
 
+/* call-seq:
+ *   IpAddress.from_integer(value) -> IpAddress
+ *
+ * Builds an address from its 32-bit representation, in host byte order.
+ *
+ * @return [IpAddress]
+ */
 static VALUE IpAddress_from_integer(VALUE klass, VALUE rb_integer) {
-    return ip_address_to_rb(sfIpAddress_fromInteger((uint32_t) NUM2UINT(rb_integer)));
+    return ip_address_to_rb(sfIpAddress_fromInteger((uint32_t)NUM2UINT(rb_integer)));
 }
 
-static VALUE IpAddress_new(VALUE klass, VALUE rb_address) {
-    if (RB_INTEGER_TYPE_P(rb_address)) {
-        return IpAddress_from_integer(klass, rb_address);
-    }
+static VALUE IpAddress_alloc(VALUE klass) {
+    IpAddress* ptr = malloc(sizeof(IpAddress));
 
-    if (RB_TYPE_P(rb_address, T_STRING)) {
-        return IpAddress_from_string(klass, rb_address);
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate IP address");
     }
 
-    if (rb_obj_is_kind_of(rb_address, rb_cIpAddress)) {
-        return ip_address_to_rb(((IpAddress *) Get_IpAddress_Struct(rb_address))->address);
-    }
+    ptr->address = sfIpAddress_None;
 
-    raise_invalid_argument_class(rb_cIpAddress);
+    return TypedData_Wrap_Struct(klass, &IpAddress_data_type, ptr);
+}
+
+/* call-seq:
+ *   IpAddress.new(address) -> IpAddress
+ *
+ * +address+ may be an Integer (32-bit representation), a String (dotted
+ * decimal or network name), or another IpAddress to copy.
+ *
+ * @return [IpAddress]
+ * @raise [TypeError] if +address+ is none of the above
+ */
+static VALUE IpAddress_initialize(VALUE self, VALUE rb_address) {
+    IpAddress* ptr = (IpAddress*)Get_IpAddress_Struct(self);
+
+    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);
+    }
 
-    return Qnil;
+    return self;
 }
 
+/* call-seq:
+ *   IpAddress.local_address -> IpAddress
+ *
+ * Returns the address of the local computer on its local network.
+ *
+ * @return [IpAddress] the address of the local computer on the local
+ *   network
+ */
 static VALUE IpAddress_local_address(VALUE klass) {
     return ip_address_to_rb(sfIpAddress_getLocalAddress());
 }
 
-static VALUE IpAddress_public_address(int argc, VALUE *argv, VALUE klass) {
+/* call-seq:
+ *   IpAddress.public_address(timeout = Time.zero) -> IpAddress
+ *
+ * Blocks while querying an external web service for the computer's
+ * public address, as seen from outside the local network.
+ *
+ * @return [IpAddress] +IpAddress::NONE+ if the request timed out or failed
+ */
+static VALUE IpAddress_public_address(int argc, VALUE* argv, VALUE klass) {
     VALUE rb_timeout;
     sfTime timeout = sfTime_Zero;
 
@@ -79,39 +136,68 @@ static VALUE IpAddress_public_address(int argc, VALUE *argv, VALUE klass) {
     return ip_address_to_rb(sfIpAddress_getPublicAddress(timeout));
 }
 
+/* call-seq: to_s -> String
+ *
+ * Returns the address in dotted decimal notation.
+ *
+ * @return [String] dotted decimal representation, e.g. +"192.168.1.1"+
+ */
 static VALUE IpAddress_to_s(VALUE self) {
     char buffer[16];
 
-    sfIpAddress_toString(((IpAddress *) Get_IpAddress_Struct(self))->address, buffer);
+    sfIpAddress_toString(((IpAddress*)Get_IpAddress_Struct(self))->address, buffer);
 
     return rb_str_new_cstr(buffer);
 }
 
+/* call-seq: to_integer -> Integer
+ *
+ * Returns the address as a 32-bit integer.
+ *
+ * @return [Integer] the 32-bit representation, in host byte order
+ */
 static VALUE IpAddress_to_integer(VALUE self) {
-    return UINT2NUM(sfIpAddress_toInteger(((IpAddress *) Get_IpAddress_Struct(self))->address));
+    return UINT2NUM(sfIpAddress_toInteger(((IpAddress*)Get_IpAddress_Struct(self))->address));
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * Returns +true+ if +other+ is an IpAddress with the same value.
+ *
+ * @return [Boolean]
+ */
 static VALUE IpAddress_eql(VALUE self, VALUE rb_other) {
-    sfIpAddress a = ((IpAddress *) Get_IpAddress_Struct(self))->address;
+    sfIpAddress a = ((IpAddress*)Get_IpAddress_Struct(self))->address;
     sfIpAddress b;
 
     if (!rb_obj_is_kind_of(rb_other, rb_cIpAddress)) {
         return Qfalse;
     }
 
-    b = ((IpAddress *) Get_IpAddress_Struct(rb_other))->address;
+    b = ((IpAddress*)Get_IpAddress_Struct(rb_other))->address;
 
     return BOOL2RB(sfIpAddress_toInteger(a) == sfIpAddress_toInteger(b));
 }
 
+/* call-seq: hash -> Integer
+ *
+ * Returns a hash value consistent with #==, so addresses work as Hash keys.
+ *
+ * @return [Integer] a hash suitable for use as a Hash key, consistent with #==
+ */
 static VALUE IpAddress_hash(VALUE self) {
-    return UINT2NUM(sfIpAddress_toInteger(((IpAddress *) Get_IpAddress_Struct(self))->address));
+    return UINT2NUM(sfIpAddress_toInteger(((IpAddress*)Get_IpAddress_Struct(self))->address));
 }
 
-void Init_IpAddress(VALUE rb_module) {
-    rb_cIpAddress = rb_define_class_under(rb_module, "IpAddress", rb_cObject);
+/* Document-class: SFML::IpAddress
+ * An IPv4 network address.
+ */
+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);
@@ -125,18 +211,24 @@ void Init_IpAddress(VALUE rb_module) {
     rb_define_method(rb_cIpAddress, "==", IpAddress_eql, 1);
     rb_define_method(rb_cIpAddress, "eql?", IpAddress_eql, 1);
 
-    rb_define_const(rb_cIpAddress, "NONE", ip_address_to_rb(sfIpAddress_None));
-    rb_define_const(rb_cIpAddress, "ANY", ip_address_to_rb(sfIpAddress_Any));
-    rb_define_const(rb_cIpAddress, "LOCAL_HOST", ip_address_to_rb(sfIpAddress_LocalHost));
-    rb_define_const(rb_cIpAddress, "BROADCAST", ip_address_to_rb(sfIpAddress_Broadcast));
+    /* An invalid/unspecified address. */
+    rb_define_const(rb_cIpAddress, "NONE", rb_obj_freeze(ip_address_to_rb(sfIpAddress_None)));
+    /* Any address, 0.0.0.0, e.g. to bind a listener to all network interfaces. */
+    rb_define_const(rb_cIpAddress, "ANY", rb_obj_freeze(ip_address_to_rb(sfIpAddress_Any)));
+    /* The local host address, 127.0.0.1. */
+    rb_define_const(rb_cIpAddress, "LOCAL_HOST",
+                    rb_obj_freeze(ip_address_to_rb(sfIpAddress_LocalHost)));
+    /* The broadcast address, 255.255.255.255. */
+    rb_define_const(rb_cIpAddress, "BROADCAST",
+                    rb_obj_freeze(ip_address_to_rb(sfIpAddress_Broadcast)));
 }
 
 VALUE Get_Klass_IpAddress(void) {
     return rb_cIpAddress;
 }
 
-void *Get_IpAddress_Struct(VALUE self) {
-    IpAddress *ptr;
+void* Get_IpAddress_Struct(VALUE self) {
+    IpAddress* ptr;
     TypedData_Get_Struct(self, IpAddress, &IpAddress_data_type, ptr);
     return ptr;
 }
@@ -147,7 +239,7 @@ sfIpAddress ip_address_from_rb(VALUE rb_address, sfIpAddress fallback) {
     }
 
     if (rb_obj_is_kind_of(rb_address, rb_cIpAddress)) {
-        return ((IpAddress *) Get_IpAddress_Struct(rb_address))->address;
+        return ((IpAddress*)Get_IpAddress_Struct(rb_address))->address;
     }
 
     if (RB_TYPE_P(rb_address, T_STRING)) {
@@ -155,7 +247,7 @@ sfIpAddress ip_address_from_rb(VALUE rb_address, sfIpAddress fallback) {
     }
 
     if (RB_INTEGER_TYPE_P(rb_address)) {
-        return sfIpAddress_fromInteger((uint32_t) NUM2UINT(rb_address));
+        return sfIpAddress_fromInteger((uint32_t)NUM2UINT(rb_address));
     }
 
     raise_invalid_argument_class(rb_cIpAddress);