plamo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cb94f3cd95aaec8494e7b8fd1d45cc0788927fc246b7d4838497de54b414382
+  data.tar.gz: 4a61dd385a36c3758d66d91daabe9bac37bf1ad56dc755353e26847e479ee073
+SHA512:
+  metadata.gz: e8667d402ecf5aac08f13592c38127bb3c28a0a4cf88d923d1a18225202f09dcd8b81690c920ff20d69085b417adb0019e096d479e9d1f05cefcc1e23cc17bf5
+  data.tar.gz: dd4cf943ce9f7aecd568e9ef37f33c954d044c77ca94d31a152e0afdc926064aa825898cd95d9d7221f1edbc54313e33a604fe68c2504d905ca0f069db1f32d1

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in plamo.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    plamo (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.5.0)
+    rake-compiler (1.0.7)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  plamo!
+  rake (~> 10.0)
+  rake-compiler
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Shogo Otake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+# plamo-ruby
+plamo-ruby is libplamo wrapper for Ruby.
+## Installation
+Please install libplamo before using plamo-ruby.
+## License
+MIT License

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("plamo") do |ext|
+  ext.lib_dir = "lib/plamo"
+end
+
+task :default => [:clobber, :compile, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "plamo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/plamo/extconf.rb

@@ -0,0 +1,11 @@
+require "mkmf"
+
+unless find_header("libplamo.h")
+  abort "libplamo is missing. please install libplamo"
+end
+
+unless find_library("plamo", "plamo_string_new")
+  abort "libplamo is missing. please install libplamo"
+end
+
+create_makefile("plamo/plamo")

data/ext/plamo/plamo.c

@@ -0,0 +1,15 @@
+#include "plamo.h"
+
+VALUE rb_mPlamo;
+
+void Init_plamo(void) {
+  rb_mPlamo = rb_define_module("Plamo");
+  Init_plamo_string_array();
+  Init_plamo_byte_array();
+  Init_plamo_http_header();
+  Init_plamo_http_query();
+  Init_plamo_request();
+  Init_plamo_response();
+  Init_plamo_middleware();
+  Init_plamo_app();
+}

data/ext/plamo/plamo.h

@@ -0,0 +1,18 @@
+#ifndef PLAMO_H
+#define PLAMO_H
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <libplamo.h>
+#include "plamo_string_array.h"
+#include "plamo_byte_array.h"
+#include "plamo_http_header.h"
+#include "plamo_http_query.h"
+#include "plamo_request.h"
+#include "plamo_response.h"
+#include "plamo_middleware.h"
+#include "plamo_app.h"
+
+extern VALUE rb_mPlamo;
+
+#endif /* PLAMO_H */

data/ext/plamo/plamo_app.c

@@ -0,0 +1,53 @@
+#include "plamo.h"
+#include "wrapper.h"
+
+VALUE rb_cPlamoApp;
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_app_destroy(wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static VALUE initialize(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  wrapper->inner = plamo_app_new();
+  return self;
+}
+
+static VALUE push_middleware(VALUE self, VALUE rb_plamo_middleware) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  Wrapper *plamo_middleware_wrapper;
+  Data_Get_Struct(rb_plamo_middleware, Wrapper, plamo_middleware_wrapper);
+  plamo_app_add_middleware(wrapper->inner, plamo_middleware_wrapper->inner);
+  return Qnil;
+}
+
+static VALUE execute(VALUE self, VALUE rb_plamo_request) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+
+  Wrapper *plamo_request_wrapper;
+  Data_Get_Struct(rb_plamo_request, Wrapper, plamo_request_wrapper);
+
+  PlamoResponse *response = plamo_app_execute(wrapper->inner, plamo_request_wrapper->inner);
+  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 = response;
+
+  return rb_plamo_response;
+}
+
+void Init_plamo_app(void) {
+  rb_cPlamoApp = rb_define_class_under(rb_mPlamo, "App", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoApp, allocate);
+  rb_define_method(rb_cPlamoApp, "initialize", initialize, 0);
+  rb_define_method(rb_cPlamoApp, "push_middleware", push_middleware, 1);
+  rb_define_method(rb_cPlamoApp, "execute", execute, 1);
+}

data/ext/plamo/plamo_app.h

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

data/ext/plamo/plamo_byte_array.c

@@ -0,0 +1,40 @@
+#include "plamo.h"
+#include "wrapper.h"
+
+VALUE rb_cPlamoByteArray;
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_byte_array_destroy(wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static VALUE initialize(VALUE self, VALUE body) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  wrapper->inner = plamo_byte_array_new((const unsigned char*)RARRAY_PTR(body), RARRAY_LEN(body));
+  return self;
+}
+
+static VALUE get_body(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  return rb_ary_new4(plamo_byte_array_get_body_size(wrapper->inner), (VALUE*)plamo_byte_array_get_body(wrapper->inner));
+}
+
+static VALUE get_size(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  return ULONG2NUM(plamo_byte_array_get_body_size(wrapper->inner));
+}
+
+void Init_plamo_byte_array(void) {
+  rb_cPlamoByteArray = rb_define_class_under(rb_mPlamo, "ByteArray", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoByteArray, allocate);
+  rb_define_method(rb_cPlamoByteArray, "initialize", initialize, 1);
+  rb_define_method(rb_cPlamoByteArray, "body", get_body, 0);
+  rb_define_method(rb_cPlamoByteArray, "size", get_size, 0);
+}

data/ext/plamo/plamo_byte_array.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_PLAMO_BYTE_ARRAY_H
+#define RUBY_PLAMO_BYTE_ARRAY_H
+
+extern VALUE rb_cPlamoByteArray;
+
+void Init_plamo_byte_array(void);
+
+#endif /* RUBY_PLAMO_BYTE_ARRAY_H */

data/ext/plamo/plamo_http_header.c

@@ -0,0 +1,77 @@
+#include "plamo.h"
+#include "wrapper.h"
+
+VALUE rb_cPlamoHttpHeader;
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_http_header_destroy(wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static VALUE initialize(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  wrapper->inner = 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));
+  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));
+  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;
+    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 VALUE each(VALUE self, VALUE key) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  plamo_http_header_for_each(wrapper->inner, 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))) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+void Init_plamo_http_header(void) {
+  rb_cPlamoHttpHeader = rb_define_class_under(rb_mPlamo, "HttpHeader", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoHttpHeader, allocate);
+  rb_define_method(rb_cPlamoHttpHeader, "initialize", initialize, 0);
+  rb_define_method(rb_cPlamoHttpHeader, "push", push, 2);
+  rb_define_method(rb_cPlamoHttpHeader, "[]", get, 1);
+  rb_define_method(rb_cPlamoHttpHeader, "each", each, 0);
+  rb_define_method(rb_cPlamoHttpHeader, "delete", delete_at, 1);
+}

data/ext/plamo/plamo_http_header.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_PLAMO_HTTP_HEADER_H
+#define RUBY_PLAMO_HTTP_HEADER_H
+
+extern VALUE rb_cPlamoHttpHeader;
+
+void Init_plamo_http_header(void);
+
+#endif /* RUBY_PLAMO_HTTP_HEADER_H */

data/ext/plamo/plamo_http_query.c

@@ -0,0 +1,61 @@
+#include "plamo.h"
+#include "wrapper.h"
+
+VALUE rb_cPlamoHttpQuery;
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_http_query_destroy(wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static VALUE initialize(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  wrapper->inner = 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));
+  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));
+  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;
+    return rb_plamo_string_array;
+  } else {
+    return Qnil;
+  }
+}
+
+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))) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+void Init_plamo_http_query(void) {
+  rb_cPlamoHttpQuery = rb_define_class_under(rb_mPlamo, "HttpQuery", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoHttpQuery, allocate);
+  rb_define_method(rb_cPlamoHttpQuery, "initialize", initialize, 0);
+  rb_define_method(rb_cPlamoHttpQuery, "push", push, 2);
+  rb_define_method(rb_cPlamoHttpQuery, "[]", get, 1);
+  rb_define_method(rb_cPlamoHttpQuery, "delete", delete_at, 1);
+}

data/ext/plamo/plamo_http_query.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_PLAMO_HTTP_QUERY_H
+#define RUBY_PLAMO_HTTP_QUERY_H
+
+extern VALUE rb_cPlamoHttpQuery;
+
+void Init_plamo_http_query(void);
+
+#endif /* RUBY_PLAMO_HTTP_QUERY_H */

data/ext/plamo/plamo_middleware.c

@@ -0,0 +1,176 @@
+#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/
+
+VALUE rb_cPlamoMiddleware;
+
+typedef struct PlamoRbCallbackConfig {
+  VALUE config;
+  VALUE callback;
+} PlamoRbCallbackConfig;
+
+typedef struct callback_t {
+  bool handled;
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+  struct callback_t *next;
+  const PlamoRbCallbackConfig *config;
+  const PlamoRequest *plamo_request;
+  PlamoResponse *plamo_response;
+} callback_t;
+
+typedef struct callback_waiting_t {
+  callback_t *callback;
+  bool abort;
+} callback_waiting_t;
+
+pthread_mutex_t g_callback_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t g_callback_cond = PTHREAD_COND_INITIALIZER;
+callback_t *g_callback_queue = NULL;
+
+static void g_callback_queue_push(callback_t *callback) {
+  callback->next = g_callback_queue;
+  g_callback_queue = callback;
+}
+
+static callback_t* g_callback_queue_pop(void) {
+  callback_t *callback = g_callback_queue;
+  if (callback) {
+    g_callback_queue = callback->next;
+  }
+  return callback;
+}
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_middleware_destroy((PlamoMiddleware*)wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static void* plamo_callback(void *args) {
+  VALUE rb_array = (VALUE)args;
+  const PlamoRbCallbackConfig *config = (const PlamoRbCallbackConfig*)rb_ary_shift(rb_array);
+  const PlamoRequest *plamo_request = (const PlamoRequest*)rb_ary_shift(rb_array);
+  PlamoResponse *plamo_response = (PlamoResponse*)rb_ary_shift(rb_array);
+  callback_t callback = {
+    .config = config,
+    .plamo_request = plamo_request,
+    .plamo_response = plamo_response,
+    .handled = false,
+  };
+  pthread_mutex_init(&callback.mutex, NULL);
+  pthread_cond_init(&callback.cond, NULL);
+
+  pthread_mutex_lock(&g_callback_mutex);
+  g_callback_queue_push(&callback);
+  pthread_mutex_unlock(&g_callback_mutex);
+
+  pthread_cond_signal(&g_callback_cond);
+
+  pthread_mutex_lock(&callback.mutex);
+  while (callback.handled == false) {
+    pthread_cond_wait(&callback.cond, &callback.mutex);
+  }
+  pthread_mutex_unlock(&callback.mutex);
+
+  pthread_mutex_destroy(&callback.mutex);
+  pthread_cond_destroy(&callback.cond);
+
+  return NULL;
+}
+
+static void before_plamo_callback(const void *config, const PlamoRequest *plamo_request, PlamoResponse *plamo_response) {
+  rb_thread_call_without_gvl(plamo_callback, (void*)rb_ary_new3(3, config, plamo_request, plamo_response), NULL, NULL);
+  return;
+}
+
+static VALUE handle_callback(void *cb) {
+  callback_t *callback = (callback_t*)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;
+
+  rb_proc_call(rb_proc, rb_ary_new3(3, rb_config, rb_plamo_request, rb_plamo_response));
+
+  pthread_mutex_lock(&callback->mutex);
+  callback->handled = true;
+  pthread_cond_signal(&callback->cond);
+  pthread_mutex_unlock(&callback->mutex);
+
+  return Qnil;
+}
+
+static void* wait_for_callback_signal(void *w) {
+  callback_waiting_t *waiting = (callback_waiting_t*)w;
+
+  pthread_mutex_lock(&g_callback_mutex);
+
+  while (waiting->abort == false && (waiting->callback = g_callback_queue_pop()) == NULL) {
+    pthread_cond_wait(&g_callback_cond, &g_callback_mutex);
+  }
+
+  pthread_mutex_unlock(&g_callback_mutex);
+
+  return NULL;
+}
+
+static void stop_waiting_for_callback_signal(void *w) {
+  callback_waiting_t *waiting = (callback_waiting_t*)w;
+
+  pthread_mutex_lock(&g_callback_mutex);
+  waiting->abort = true;
+  pthread_cond_signal(&g_callback_cond);
+  pthread_mutex_unlock(&g_callback_mutex);
+}
+
+static VALUE event_thread(void *_) {
+  callback_waiting_t waiting = {
+    .callback = NULL,
+    .abort = false
+  };
+
+  while (waiting.abort == false) {
+    rb_thread_call_without_gvl(wait_for_callback_signal, &waiting, stop_waiting_for_callback_signal, &waiting);
+
+    if (waiting.callback) {
+      rb_thread_create(handle_callback, (void*)waiting.callback);
+    }
+  }
+
+  return Qnil;
+}
+
+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);
+
+  return self;
+}
+
+void Init_plamo_middleware(void) {
+  rb_cPlamoMiddleware = rb_define_class_under(rb_mPlamo, "Middleware", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoMiddleware, allocate);
+  rb_define_method(rb_cPlamoMiddleware, "initialize", initialize, 2);
+  rb_thread_create(event_thread, NULL);
+}

data/ext/plamo/plamo_middleware.h

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

data/ext/plamo/plamo_request.c

@@ -0,0 +1,118 @@
+#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 VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+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
+                                 : sym_http_1_0 == rb_version ? PlamoHttpVersionHttp10
+                                 : PlamoHttpVersionHttp09;
+  const char *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);
+  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;
+}
+
+static VALUE version(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  switch (((PlamoRequest*)wrapper->inner)->version) {
+    case PlamoHttpVersionHttp20:
+      return sym_http_2_0;
+    case PlamoHttpVersionHttp11:
+      return sym_http_1_1;
+    case PlamoHttpVersionHttp10:
+      return sym_http_1_0;
+    default:
+      return sym_http_0_9;
+  }
+}
+
+static VALUE method(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  return rb_str_new2(plamo_string_get_char(((PlamoRequest*)wrapper->inner)->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));
+}
+
+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;
+  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;
+  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;
+  return rb_plamo_byte_array;
+}
+
+void Init_plamo_request(void) {
+  sym_http = ID2SYM(rb_intern("http"));
+  sym_https = ID2SYM(rb_intern("https"));
+  sym_http_2_0 = ID2SYM(rb_intern("http_2_0"));
+  sym_http_1_1 = ID2SYM(rb_intern("http_1_1"));
+  sym_http_1_0 = ID2SYM(rb_intern("http_1_0"));
+  sym_http_0_9 = ID2SYM(rb_intern("http_0_9"));
+
+  rb_cPlamoRequest = rb_define_class_under(rb_mPlamo, "Request", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoRequest, allocate);
+  rb_define_method(rb_cPlamoRequest, "initialize", initialize, 7);
+  rb_define_method(rb_cPlamoRequest, "scheme", scheme, 0);
+  rb_define_method(rb_cPlamoRequest, "version", version, 0);
+  rb_define_method(rb_cPlamoRequest, "method", method, 0);
+  rb_define_method(rb_cPlamoRequest, "path", path, 0);
+  rb_define_method(rb_cPlamoRequest, "query", query, 0);
+  rb_define_method(rb_cPlamoRequest, "header", header, 0);
+  rb_define_method(rb_cPlamoRequest, "body", body, 0);
+}

data/ext/plamo/plamo_request.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_PLAMO_REQUEST_H
+#define RUBY_PLAMO_REQUEST_H
+
+extern VALUE rb_cPlamoRequest;
+
+void Init_plamo_request(void);
+
+#endif /* RUBY_PLAMO_REQUEST_H */

data/ext/plamo/plamo_response.c

@@ -0,0 +1,89 @@
+#include "plamo.h"
+#include "wrapper.h"
+
+VALUE rb_cPlamoResponse;
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_response_destroy(wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static VALUE initialize(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  wrapper->inner = plamo_response_new();
+  return self;
+}
+
+static VALUE status_code(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  return UINT2NUM(((PlamoResponse*)wrapper->inner)->status_code);
+}
+
+static VALUE set_status_code(VALUE self, VALUE code) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  ((PlamoResponse*)wrapper->inner)->status_code = FIX2UINT(code);
+  return code;
+}
+
+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 = ((PlamoResponse*)wrapper->inner)->header;
+  return rb_plamo_http_header;
+}
+
+static VALUE body(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  if (((PlamoResponse*)wrapper->inner)->body != NULL) {
+    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 = ((PlamoResponse*)wrapper->inner)->body;
+    return rb_plamo_byte_array;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE set_body(VALUE self, VALUE rb_body) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+
+  if (strcmp("String", rb_class2name(rb_obj_class(rb_body))) == 0) {
+    struct RString *rstring = RSTRING(rb_body);
+    ((PlamoResponse*)wrapper->inner)->body = plamo_byte_array_new(RSTRING_PTR(rstring), RSTRING_LEN(rstring));
+  } else {
+    VALUE *array = RARRAY_PTR(rb_body);
+    size_t len = RARRAY_LEN(rb_body);
+    unsigned char *buf = malloc(sizeof(unsigned char) * len);
+    for (size_t i = 0; i < len; i++) {
+      buf[i] = NUM2CHR(array[i]);
+    }
+    ((PlamoResponse*)wrapper->inner)->body = plamo_byte_array_new(buf, len);
+    free(array);
+  }
+
+  return self;
+}
+
+void Init_plamo_response(void) {
+  rb_cPlamoResponse = rb_define_class_under(rb_mPlamo, "Response", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoResponse, allocate);
+  rb_define_method(rb_cPlamoResponse, "initialize", initialize, 0);
+  rb_define_method(rb_cPlamoResponse, "status_code", status_code, 0);
+  rb_define_method(rb_cPlamoResponse, "status_code=", set_status_code, 1);
+  rb_define_method(rb_cPlamoResponse, "header", header, 0);
+  rb_define_method(rb_cPlamoResponse, "body", body, 0);
+  rb_define_method(rb_cPlamoResponse, "body=", set_body, 1);
+}

data/ext/plamo/plamo_response.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_PLAMO_RESPONSE_H
+#define RUBY_PLAMO_RESPONSE_H
+
+extern VALUE rb_cPlamoResponse;
+
+void Init_plamo_response(void);
+
+#endif /* RUBY_PLAMO_RESPONSE_H */

data/ext/plamo/plamo_string_array.c

@@ -0,0 +1,94 @@
+#include "plamo.h"
+#include "wrapper.h"
+
+VALUE rb_cPlamoStringArray;
+
+static void deallocate(Wrapper *wrapper) {
+  plamo_string_array_destroy(wrapper->inner);
+  free(wrapper);
+}
+
+static VALUE allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, deallocate, malloc(sizeof(Wrapper)));
+}
+
+static VALUE initialize(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  wrapper->inner = plamo_string_array_new();
+  return self;
+}
+
+static VALUE push(VALUE self, VALUE rb_string) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  plamo_string_array_add(wrapper->inner, StringValueCStr(rb_string));
+  return Qnil;
+}
+
+static VALUE first(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  const char *str = plamo_string_array_get_first(wrapper->inner);
+  if (str != NULL) {
+    return rb_str_new2(str);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE last(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  const char *str = plamo_string_array_get_last(wrapper->inner);
+  if (str != NULL) {
+    return rb_str_new2(str);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE get_at(VALUE self, VALUE index) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  const char *str = plamo_string_array_get_at(wrapper->inner, FIX2ULONG(index));
+  if (str != NULL) {
+    return rb_str_new2(str);
+  } else {
+    return Qnil;
+  }
+}
+
+static void execute_each(const char *str) {
+  rb_yield(rb_str_new2(str));
+}
+
+static VALUE each(VALUE self) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  plamo_string_array_for_each(wrapper->inner, execute_each);
+  return Qnil;
+}
+
+static VALUE delete_at(VALUE self, VALUE index) {
+  Wrapper *wrapper;
+  Data_Get_Struct(self, Wrapper, wrapper);
+  if (plamo_string_array_remove_at(wrapper->inner, FIX2ULONG(index))) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+void Init_plamo_string_array(void) {
+  rb_cPlamoStringArray = rb_define_class_under(rb_mPlamo, "StringArray", rb_cObject);
+  rb_define_alloc_func(rb_cPlamoStringArray, allocate);
+  rb_define_method(rb_cPlamoStringArray, "initialize", initialize, 0);
+  rb_define_method(rb_cPlamoStringArray, "push", push, 1);
+  rb_define_method(rb_cPlamoStringArray, "first", first, 0);
+  rb_define_method(rb_cPlamoStringArray, "last", last, 0);
+  rb_define_method(rb_cPlamoStringArray, "[]", get_at, 1);
+  rb_define_method(rb_cPlamoStringArray, "each", each, 0);
+  rb_define_method(rb_cPlamoStringArray, "delete_at", delete_at, 1);
+}
+

data/ext/plamo/plamo_string_array.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_PLAMO_STRING_ARRAY_H
+#define RUBY_PLAMO_STRING_ARRAY_H
+
+extern VALUE rb_cPlamoStringArray;
+
+void Init_plamo_string_array(void);
+
+#endif /* RUBY_PLAMO_STRING_ARRAY_H */

data/ext/plamo/wrapper.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_WRAPPER_H
+#define RUBY_WRAPPER_H
+
+typedef struct Wrapper {
+  void *inner;
+} Wrapper;
+
+#endif /* RUBY_WRAPPER_H */

data/lib/plamo/version.rb

@@ -0,0 +1,3 @@
+module Plamo
+  VERSION = "0.1.0"
+end

data/lib/plamo.rb

@@ -0,0 +1,7 @@
+require "plamo/version"
+require "plamo/plamo"
+
+module Plamo
+  HTTP_SCHEMES = [:http, :https].freeze
+  HTTP_VERSIONS = [:http_0_9, :http_1_0, :http_1_1, :http_2_0].freeze
+end

data/plamo.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "plamo/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "plamo"
+  spec.version       = Plamo::VERSION
+  spec.authors       = ["Shogo Otake"]
+  spec.email         = ["shogo.otake@gmail.com"]
+
+  spec.summary       = "Ruby Bindings for libplamo"
+  spec.homepage      = "https://plamo.org"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/plamo/plamo-ruby"
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/plamo/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: plamo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shogo Otake
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- shogo.otake@gmail.com
+executables: []
+extensions:
+- ext/plamo/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/plamo/extconf.rb
+- ext/plamo/plamo.c
+- ext/plamo/plamo.h
+- ext/plamo/plamo_app.c
+- ext/plamo/plamo_app.h
+- ext/plamo/plamo_byte_array.c
+- ext/plamo/plamo_byte_array.h
+- ext/plamo/plamo_http_header.c
+- ext/plamo/plamo_http_header.h
+- ext/plamo/plamo_http_query.c
+- ext/plamo/plamo_http_query.h
+- ext/plamo/plamo_middleware.c
+- ext/plamo/plamo_middleware.h
+- ext/plamo/plamo_request.c
+- ext/plamo/plamo_request.h
+- ext/plamo/plamo_response.c
+- ext/plamo/plamo_response.h
+- ext/plamo/plamo_string_array.c
+- ext/plamo/plamo_string_array.h
+- ext/plamo/wrapper.h
+- lib/plamo.rb
+- lib/plamo/version.rb
+- plamo.gemspec
+homepage: https://plamo.org
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://plamo.org
+  source_code_uri: https://github.com/plamo/plamo-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Ruby Bindings for libplamo
+test_files: []