plamo 0.2.0 → 0.3.0

data/ext/plamo/plamo_form_data_field_array.h

@@ -0,0 +1,9 @@
+#ifndef RUBY_PLAMO_FORM_DATA_FIELD_ARRAY_H
+#define RUBY_PLAMO_FORM_DATA_FIELD_ARRAY_H
+
+extern VALUE rb_cPlamoFormDataFieldArray;
+extern const rb_data_type_t rb_plamo_form_data_field_array_type;
+
+void Init_plamo_form_data_field_array(void);
+
+#endif /* RUBY_PLAMO_FORM_DATA_FIELD_ARRAY_H */

data/ext/plamo/plamo_form_data_file.c

@@ -0,0 +1,69 @@
+#include "plamo.h"
+
+VALUE rb_cPlamoFormDataFile;
+
+const rb_data_type_t rb_plamo_form_data_file_type = {
+  "FormDataFile",
+  {
+    NULL,
+    NULL,
+    NULL,
+  },
+  NULL,
+  NULL,
+  0,
+};
+
+static VALUE allocate(VALUE klass) {
+  return TypedData_Wrap_Struct(klass, &rb_plamo_form_data_file_type, NULL);
+}
+
+static VALUE get_content_type(VALUE self) {
+  PlamoFormDataFile *plamo_form_data_file;
+  TypedData_Get_Struct(self, PlamoFormDataFile, &rb_plamo_form_data_file_type, plamo_form_data_file);
+  const char *str = plamo_form_data_file_get_content_type(plamo_form_data_file);
+  if (str != NULL) {
+    return rb_str_new2(str);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE get_file_name(VALUE self) {
+  PlamoFormDataFile *plamo_form_data_file;
+  TypedData_Get_Struct(self, PlamoFormDataFile, &rb_plamo_form_data_file_type, plamo_form_data_file);
+  const char *str = plamo_form_data_file_get_file_name(plamo_form_data_file);
+  if (str != NULL) {
+    return rb_str_new2(str);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE get_body(VALUE self) {
+  PlamoFormDataFile *plamo_form_data_file;
+  TypedData_Get_Struct(self, PlamoFormDataFile, &rb_plamo_form_data_file_type, plamo_form_data_file);
+  const size_t size = plamo_form_data_file_get_body_size(plamo_form_data_file);
+  const unsigned char *body = plamo_form_data_file_get_body(plamo_form_data_file);
+  VALUE rb_array = rb_ary_new2(size);
+  for (int i = 0; i < size; i++) {
+    rb_ary_store(rb_array, i, CHR2FIX(*(body + i)));
+  }
+  OBJ_FREEZE(rb_array);
+  return rb_array;
+}
+
+static VALUE get_body_size(VALUE self) {
+  PlamoFormDataFile *plamo_form_data_file;
+  TypedData_Get_Struct(self, PlamoFormDataFile, &rb_plamo_form_data_file_type, plamo_form_data_file);
+  return SIZET2NUM(plamo_form_data_file_get_body_size(plamo_form_data_file));
+}
+
+void Init_plamo_form_data_file(void) {
+  rb_cPlamoFormDataFile = rb_define_class_under(rb_mPlamo, "FormDataFile", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoFormDataFile, allocate);
+  rb_define_method(rb_cPlamoFormDataFile, "content_type", get_content_type, 0);
+  rb_define_method(rb_cPlamoFormDataFile, "file_name", get_file_name, 0);
+  rb_define_method(rb_cPlamoFormDataFile, "size", get_body_size, 0);
+  rb_define_method(rb_cPlamoFormDataFile, "body", get_body, 0);
+}

data/ext/plamo/plamo_form_data_file.h

@@ -0,0 +1,9 @@
+#ifndef RUBY_PLAMO_FORM_DATA_FILE_H
+#define RUBY_PLAMO_FORM_DATA_FILE_H
+
+extern VALUE rb_cPlamoFormDataFile;
+extern const rb_data_type_t rb_plamo_form_data_file_type;
+
+void Init_plamo_form_data_file(void);
+
+#endif /* RUBY_PLAMO_FORM_DATA_FILE_H */

data/ext/plamo/plamo_form_urlencoded.c

@@ -0,0 +1,62 @@
+#include "plamo.h"
+
+VALUE rb_cPlamoFormUrlencoded;
+
+static void deallocate(void *plamo_form_urlencoded) {
+  plamo_form_urlencoded_destroy(plamo_form_urlencoded);
+}
+
+static const rb_data_type_t rb_plamo_form_urlencoded_type = {
+  "FormUrlencoded",
+  {
+    NULL,
+    deallocate,
+    NULL,
+  },
+  NULL,
+  NULL,
+  0,
+};
+
+static VALUE allocate(VALUE klass) {
+  return TypedData_Wrap_Struct(klass, &rb_plamo_form_urlencoded_type, NULL);
+}
+
+static VALUE initialize(VALUE self, VALUE request) {
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(request, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  DATA_PTR(self) = plamo_form_urlencoded_new(plamo_request);
+  return self;
+}
+
+static VALUE get(VALUE self, VALUE key) {
+  PlamoFormUrlencoded *plamo_form_urlencoded;
+  TypedData_Get_Struct(self, PlamoFormUrlencoded, &rb_plamo_form_urlencoded_type, plamo_form_urlencoded);
+  const PlamoStringArray *plamo_string_array = plamo_form_urlencoded_get(plamo_form_urlencoded, StringValueCStr(key));
+  if (plamo_string_array != NULL) {
+    VALUE rb_plamo_string_array = TypedData_Wrap_Struct(rb_cPlamoStringArray, &rb_plamo_string_array_type, (PlamoStringArray*)plamo_string_array);
+    OBJ_FREEZE(rb_plamo_string_array);
+    return rb_plamo_string_array;
+  } else {
+    return Qnil;
+  }
+}
+
+static void execute_each(const char *key, const char *value) {
+  rb_yield(rb_ary_new3(2, rb_str_new2(key), rb_str_new2(value)));
+}
+
+static VALUE each(VALUE self) {
+  PlamoFormUrlencoded *plamo_form_urlencoded;
+  TypedData_Get_Struct(self, PlamoFormUrlencoded, &rb_plamo_form_urlencoded_type, plamo_form_urlencoded);
+  plamo_form_urlencoded_for_each(plamo_form_urlencoded, execute_each);
+  return Qnil;
+}
+
+void Init_plamo_form_urlencoded(void) {
+  rb_cPlamoFormUrlencoded = rb_define_class_under(rb_mPlamo, "FormUrlencoded", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoFormUrlencoded, allocate);
+  rb_define_method(rb_cPlamoFormUrlencoded, "initialize", initialize, 1);
+  rb_define_method(rb_cPlamoFormUrlencoded, "[]", get, 1);
+  rb_define_method(rb_cPlamoFormUrlencoded, "each", each, 0);
+}

data/ext/plamo/plamo_form_urlencoded.h

@@ -0,0 +1,6 @@
+#ifndef RUBY_PLAMO_FORM_URLENCODED_H
+#define RUBY_PLAMO_FORM_URLENCODED_H
+
+void Init_plamo_form_urlencoded(void);
+
+#endif /* RUBY_PLAMO_FORM_URLENCODED_H */

data/ext/plamo/plamo_http_header.c

@@ -1,65 +1,66 @@
 #include "plamo.h"
-#include "wrapper.h"
 
 VALUE rb_cPlamoHttpHeader;
 
-static void deallocate(Wrapper *wrapper) {
-  plamo_http_header_destroy(wrapper->inner);
-  free(wrapper);
+static void deallocate(void *plamo_http_header) {
+  plamo_http_header_destroy(plamo_http_header);
 }
 
+const rb_data_type_t rb_plamo_http_header_type = {
+  "HttpHeader",
+  {
+    NULL,
+    deallocate,
+    NULL,
+  },
+  NULL,
+  NULL,
+  0,
+};
+
 static VALUE allocate(VALUE klass) {
-  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+  return TypedData_Wrap_Struct(klass, &rb_plamo_http_header_type, NULL);
 }
 
 static VALUE initialize(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  wrapper->inner = plamo_http_header_new();
+  DATA_PTR(self) = plamo_http_header_new();
   return self;
 }
 
 static VALUE push(VALUE self, VALUE key, VALUE value) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  plamo_http_header_add(wrapper->inner, StringValueCStr(key), StringValueCStr(value));
+  PlamoHttpHeader *plamo_http_header;
+  TypedData_Get_Struct(self, PlamoHttpHeader, &rb_plamo_http_header_type, plamo_http_header);
+  plamo_http_header_add(plamo_http_header, StringValueCStr(key), StringValueCStr(value));
   return Qnil;
 }
 
 static VALUE get(VALUE self, VALUE key) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  PlamoStringArray *plamo_string_array = plamo_http_header_get(wrapper->inner, StringValueCStr(key));
+  PlamoHttpHeader *plamo_http_header;
+  TypedData_Get_Struct(self, PlamoHttpHeader, &rb_plamo_http_header_type, plamo_http_header);
+  PlamoStringArray *plamo_string_array = plamo_http_header_get(plamo_http_header, StringValueCStr(key));
   if (plamo_string_array != NULL) {
-    VALUE rb_plamo_string_array = Data_Wrap_Struct(rb_cPlamoStringArray, NULL, free, malloc(sizeof(Wrapper)));
-    Wrapper *wrapper2;
-    Data_Get_Struct(rb_plamo_string_array, Wrapper, wrapper2);
-    wrapper2->inner = plamo_string_array;
+    VALUE rb_plamo_string_array = TypedData_Wrap_Struct(rb_cPlamoStringArray, &rb_plamo_string_array_type, plamo_string_array);
     return rb_plamo_string_array;
   } else {
     return Qnil;
   }
 }
 
-static void execute_each(const char *key, PlamoStringArray *values) {
-  Wrapper *wrapper;
-  VALUE rb_plamo_string_array = Data_Wrap_Struct(rb_cPlamoStringArray, NULL, free, malloc(sizeof(Wrapper)));
-  Data_Get_Struct(rb_plamo_string_array, Wrapper, wrapper);
-  wrapper->inner = values;
-  rb_yield(rb_ary_new3(2, rb_str_new2(key), rb_plamo_string_array));
+static void execute_each(const char *key, const char *value) {
+  rb_yield(rb_ary_new3(2, rb_str_new2(key), rb_str_new2(value)));
 }
 
-static VALUE each(VALUE self, VALUE key) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  plamo_http_header_for_each(wrapper->inner, execute_each);
+static VALUE each(VALUE self) {
+  PlamoHttpHeader *plamo_http_header;
+  TypedData_Get_Struct(self, PlamoHttpHeader, &rb_plamo_http_header_type, plamo_http_header);
+  plamo_http_header_for_each(plamo_http_header, execute_each);
   return Qnil;
 }
 
 static VALUE delete_at(VALUE self, VALUE key) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  if (plamo_http_header_remove(wrapper->inner, StringValueCStr(key))) {
+  PlamoHttpHeader *plamo_http_header;
+  TypedData_Get_Struct(self, PlamoHttpHeader, &rb_plamo_http_header_type, plamo_http_header);
+  if (plamo_http_header_remove(plamo_http_header, StringValueCStr(key))) {
     return Qtrue;
   } else {
     return Qfalse;

data/ext/plamo/plamo_http_header.h

@@ -2,6 +2,7 @@
 #define RUBY_PLAMO_HTTP_HEADER_H
 
 extern VALUE rb_cPlamoHttpHeader;
+extern const rb_data_type_t rb_plamo_http_header_type;
 
 void Init_plamo_http_header(void);
 

data/ext/plamo/plamo_http_query.c

@@ -1,40 +1,45 @@
 #include "plamo.h"
-#include "wrapper.h"
 
 VALUE rb_cPlamoHttpQuery;
 
-static void deallocate(Wrapper *wrapper) {
-  plamo_http_query_destroy(wrapper->inner);
-  free(wrapper);
+static void deallocate(void *plamo_http_query) {
+  plamo_http_query_destroy(plamo_http_query);
 }
 
+const rb_data_type_t rb_plamo_http_query_type = {
+  "HttpQuery",
+  {
+    NULL,
+    deallocate,
+    NULL,
+  },
+  NULL,
+  NULL,
+  0,
+};
+
 static VALUE allocate(VALUE klass) {
-  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+  return TypedData_Wrap_Struct(klass, &rb_plamo_http_query_type, NULL);
 }
 
 static VALUE initialize(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  wrapper->inner = plamo_http_query_new();
+  DATA_PTR(self) = plamo_http_query_new();
   return self;
 }
 
 static VALUE push(VALUE self, VALUE key, VALUE value) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  plamo_http_query_add(wrapper->inner, StringValueCStr(key), StringValueCStr(value));
+  PlamoHttpQuery *plamo_http_query;
+  TypedData_Get_Struct(self, PlamoHttpQuery, &rb_plamo_http_query_type, plamo_http_query);
+  plamo_http_query_add(plamo_http_query, StringValueCStr(key), StringValueCStr(value));
   return Qnil;
 }
 
 static VALUE get(VALUE self, VALUE key) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  PlamoStringArray *plamo_string_array = plamo_http_query_get(wrapper->inner, StringValueCStr(key));
+  PlamoHttpQuery *plamo_http_query;
+  TypedData_Get_Struct(self, PlamoHttpQuery, &rb_plamo_http_query_type, plamo_http_query);
+  PlamoStringArray *plamo_string_array = plamo_http_query_get(plamo_http_query, StringValueCStr(key));
   if (plamo_string_array != NULL) {
-    VALUE rb_plamo_string_array = Data_Wrap_Struct(rb_cPlamoStringArray, NULL, free, malloc(sizeof(Wrapper)));
-    Wrapper *wrapper2;
-    Data_Get_Struct(rb_plamo_string_array, Wrapper, wrapper2);
-    wrapper2->inner = plamo_string_array;
+    VALUE rb_plamo_string_array = TypedData_Wrap_Struct(rb_cPlamoStringArray, &rb_plamo_string_array_type, plamo_string_array);
     return rb_plamo_string_array;
   } else {
     return Qnil;
@@ -42,9 +47,9 @@ static VALUE get(VALUE self, VALUE key) {
 }
 
 static VALUE delete_at(VALUE self, VALUE key) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  if (plamo_http_query_remove(wrapper->inner, StringValueCStr(key))) {
+  PlamoHttpQuery *plamo_http_query;
+  TypedData_Get_Struct(self, PlamoHttpQuery, &rb_plamo_http_query_type, plamo_http_query);
+  if (plamo_http_query_remove(plamo_http_query, StringValueCStr(key))) {
     return Qtrue;
   } else {
     return Qfalse;

data/ext/plamo/plamo_http_query.h

@@ -2,6 +2,7 @@
 #define RUBY_PLAMO_HTTP_QUERY_H
 
 extern VALUE rb_cPlamoHttpQuery;
+extern const rb_data_type_t rb_plamo_http_query_type;
 
 void Init_plamo_http_query(void);
 

data/ext/plamo/plamo_middleware.c

@@ -1,11 +1,10 @@
 #include "plamo.h"
-#include "wrapper.h"
 #include <stdbool.h>
 #include <pthread.h>
 #include <ruby/thread.h>
 
 // This hack is reference the below post.
-// https://www.burgestrand.se//articles/asynchronous-callbacks-in-ruby-c-extensions/
+// https://www.burgestrand.se/articles/asynchronous-callbacks-in-ruby-c-extensions/
 
 VALUE rb_cPlamoMiddleware;
 
@@ -46,13 +45,24 @@ static callback_t* g_callback_queue_pop(void) {
   return callback;
 }
 
-static void deallocate(Wrapper *wrapper) {
-  plamo_middleware_destroy((PlamoMiddleware*)wrapper->inner);
-  free(wrapper);
+static void deallocate(void *plamo_middleware) {
+  plamo_middleware_destroy(plamo_middleware);
 }
 
+const rb_data_type_t rb_plamo_middleware_type = {
+  "Middleware",
+  {
+    NULL,
+    deallocate,
+    NULL,
+  },
+  NULL,
+  NULL,
+  0,
+};
+
 static VALUE allocate(VALUE klass) {
-  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+  return TypedData_Wrap_Struct(klass, &rb_plamo_middleware_type, NULL);
 }
 
 static void* plamo_callback(void *args) {
@@ -98,14 +108,8 @@ static VALUE handle_callback(void *cb) {
   VALUE rb_config = callback->config->config;
   VALUE rb_proc = callback->config->callback;
 
-  VALUE rb_plamo_request = Data_Wrap_Struct(rb_cPlamoRequest, NULL, free, malloc(sizeof(Wrapper)));
-  Wrapper *plamo_request_wrapper;
-  Data_Get_Struct(rb_plamo_request, Wrapper, plamo_request_wrapper);
-  plamo_request_wrapper->inner = (PlamoRequest*)callback->plamo_request;
-  VALUE rb_plamo_response = Data_Wrap_Struct(rb_cPlamoResponse, NULL, free, malloc(sizeof(Wrapper)));
-  Wrapper *plamo_response_wrapper;
-  Data_Get_Struct(rb_plamo_response, Wrapper, plamo_response_wrapper);
-  plamo_response_wrapper->inner = callback->plamo_response;
+  VALUE rb_plamo_request = TypedData_Wrap_Struct(rb_cPlamoRequest, &rb_plamo_request_type, (PlamoRequest*)callback->plamo_request);
+  VALUE rb_plamo_response = TypedData_Wrap_Struct(rb_cPlamoResponse, &rb_plamo_response_type, callback->plamo_response);
 
   rb_proc_call(rb_proc, rb_ary_new3(3, rb_config, rb_plamo_request, rb_plamo_response));
 
@@ -158,13 +162,10 @@ static VALUE event_thread(void *_) {
 }
 
 static VALUE initialize(VALUE self, VALUE rb_config, VALUE rb_callback) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
   PlamoRbCallbackConfig *plamo_rb_calback_config = malloc(sizeof(PlamoRbCallbackConfig));
   plamo_rb_calback_config->config = rb_config;
   plamo_rb_calback_config->callback = rb_callback;
-  wrapper->inner = plamo_middleware_new(plamo_rb_calback_config, before_plamo_callback);
-
+  DATA_PTR(self) = plamo_middleware_new(plamo_rb_calback_config, before_plamo_callback);
   return self;
 }
 

data/ext/plamo/plamo_middleware.h

@@ -2,5 +2,6 @@
 #define RUBY_PLAMO_MIDDLEWARE_H
 
 void Init_plamo_middleware(void);
+extern const rb_data_type_t rb_plamo_middleware_type;
 
 #endif /* RUBY_PLAMO_MIDDLEWARE_H */

data/ext/plamo/plamo_request.c

@@ -1,22 +1,30 @@
 #include "plamo.h"
-#include "wrapper.h"
 
 VALUE rb_cPlamoRequest;
 
 static VALUE sym_http, sym_https, sym_http_2_0, sym_http_1_1, sym_http_1_0, sym_http_0_9;
 
-static void deallocate(Wrapper *wrapper) {
-  plamo_request_destroy(wrapper->inner);
-  free(wrapper);
+static void deallocate(void *plamo_request) {
+  plamo_request_destroy(plamo_request);
 }
 
+const rb_data_type_t rb_plamo_request_type = {
+  "Request",
+  {
+    NULL,
+    deallocate,
+    NULL,
+  },
+  NULL,
+  NULL,
+  0,
+};
+
 static VALUE allocate(VALUE klass) {
-  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+  return TypedData_Wrap_Struct(klass, &rb_plamo_request_type, NULL);
 }
 
 static VALUE initialize(VALUE self, VALUE rb_scheme, VALUE rb_version, VALUE rb_method, VALUE rb_path, VALUE rb_query, VALUE rb_header, VALUE rb_body) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
   const PlamoScheme scheme = sym_http == rb_scheme ? PlamoSchemeHttp : PlamoSchemeHttps;
   const PlamoHttpVersion version = sym_http_2_0 == rb_version ? PlamoHttpVersionHttp20
                                  : sym_http_1_1 == rb_version ? PlamoHttpVersionHttp11
@@ -29,26 +37,26 @@ static VALUE initialize(VALUE self, VALUE rb_scheme, VALUE rb_version, VALUE rb_
     method.undefined_http_method = StringValueCStr(rb_method);
   }
   const char *path = StringValueCStr(rb_path);
-  Wrapper *plamo_http_query_wrapper;
-  Data_Get_Struct(rb_query, Wrapper, plamo_http_query_wrapper);
-  Wrapper *plamo_http_header_wrapper;
-  Data_Get_Struct(rb_header, Wrapper, plamo_http_header_wrapper);
-  Wrapper *plamo_byte_array_wrapper;
-  Data_Get_Struct(rb_body, Wrapper, plamo_byte_array_wrapper);
-  wrapper->inner = plamo_request_new(scheme, version, method, path, plamo_http_query_wrapper->inner, plamo_http_header_wrapper->inner, plamo_byte_array_wrapper->inner);
+  PlamoHttpQuery *plamo_http_query;
+  TypedData_Get_Struct(rb_query, PlamoHttpQuery, &rb_plamo_http_query_type, plamo_http_query);
+  PlamoHttpHeader *plamo_http_header;
+  TypedData_Get_Struct(rb_header, PlamoHttpHeader, &rb_plamo_http_header_type, plamo_http_header);
+  PlamoByteArray *plamo_byte_array;
+  TypedData_Get_Struct(rb_body, PlamoByteArray, &rb_plamo_byte_array_type, plamo_byte_array);
+  DATA_PTR(self) = plamo_request_new(scheme, version, method, path, plamo_http_query, plamo_http_header, plamo_byte_array);
   return self;
 }
 
 static VALUE scheme(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  return ((PlamoRequest*)wrapper->inner)->scheme == PlamoSchemeHttp ? sym_http : sym_https;
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  return plamo_request->scheme == PlamoSchemeHttp ? sym_http : sym_https;
 }
 
 static VALUE version(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  switch (((PlamoRequest*)wrapper->inner)->version) {
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  switch (plamo_request->version) {
     case PlamoHttpVersionHttp20:
       return sym_http_2_0;
     case PlamoHttpVersionHttp11:
@@ -61,9 +69,9 @@ static VALUE version(VALUE self) {
 }
 
 static VALUE method(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  PlamoDefinedHttpMethod method = ((PlamoRequest*)wrapper->inner)->method.defined_http_method;
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  PlamoDefinedHttpMethod method = plamo_request->method.defined_http_method;
   if (method == PLAMO_HTTP_METHOD_GET) {
     return rb_str_new2("GET");
   } else if (method == PLAMO_HTTP_METHOD_POST) {
@@ -83,43 +91,34 @@ static VALUE method(VALUE self) {
   } else if (method == PLAMO_HTTP_METHOD_PATCH) {
     return rb_str_new2("PATCH");
   } else {
-    return rb_str_new2(((PlamoRequest*)wrapper->inner)->method.undefined_http_method);
+    return rb_str_new2(plamo_request->method.undefined_http_method);
   }
 }
 
 static VALUE path(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  return rb_str_new2(plamo_string_get_char(((PlamoRequest*)wrapper->inner)->path));
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  return rb_str_new2(plamo_string_get_char(plamo_request->path));
 }
 
 static VALUE query(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  VALUE rb_plamo_http_query = Data_Wrap_Struct(rb_cPlamoHttpQuery, NULL, free, malloc(sizeof(Wrapper)));
-  Wrapper *plamo_http_query_wrapper;
-  Data_Get_Struct(rb_plamo_http_query, Wrapper, plamo_http_query_wrapper);
-  plamo_http_query_wrapper->inner = ((PlamoRequest*)wrapper->inner)->query;
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  VALUE rb_plamo_http_query = TypedData_Wrap_Struct(rb_cPlamoHttpQuery, &rb_plamo_http_query_type, plamo_request->query);
   return rb_plamo_http_query;
 }
 
 static VALUE header(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  VALUE rb_plamo_http_header = Data_Wrap_Struct(rb_cPlamoHttpHeader, NULL, free, malloc(sizeof(Wrapper)));
-  Wrapper *plamo_http_header_wrapper;
-  Data_Get_Struct(rb_plamo_http_header, Wrapper, plamo_http_header_wrapper);
-  plamo_http_header_wrapper->inner = ((PlamoRequest*)wrapper->inner)->header;
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  VALUE rb_plamo_http_header = TypedData_Wrap_Struct(rb_cPlamoHttpHeader, &rb_plamo_http_header_type, plamo_request->header);
   return rb_plamo_http_header;
 }
 
 static VALUE body(VALUE self) {
-  Wrapper *wrapper;
-  Data_Get_Struct(self, Wrapper, wrapper);
-  VALUE rb_plamo_byte_array = Data_Wrap_Struct(rb_cPlamoByteArray, NULL, free, malloc(sizeof(Wrapper)));
-  Wrapper *plamo_byte_array_wrapper;
-  Data_Get_Struct(rb_plamo_byte_array, Wrapper, plamo_byte_array_wrapper);
-  plamo_byte_array_wrapper->inner = ((PlamoRequest*)wrapper->inner)->body;
+  PlamoRequest *plamo_request;
+  TypedData_Get_Struct(self, PlamoRequest, &rb_plamo_request_type, plamo_request);
+  VALUE rb_plamo_byte_array = TypedData_Wrap_Struct(rb_cPlamoByteArray, &rb_plamo_byte_array_type, plamo_request->body);
   return rb_plamo_byte_array;
 }