gohttp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6970bde6a9b5abb0c5dba6d1d24dd8d45e6d5f03
+  data.tar.gz: a49d93842ba8fbb32e5daf62c2cadfc406013d24
+SHA512:
+  metadata.gz: 76290ca49818def17d3d107273b84811511d668539c3cecd01a79250d39ac50e52ad421ea6721177438c07936b7376024422950998e3cc45e44e6df22b181387
+  data.tar.gz: 37f5738e18ce5210bcca7afc3a13860138eb23021178cb5783537b2969d11bc53f07da103bc9710f73f6c4019510c8c5a3d679fa07a49409026f498334418828

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.swp
+*.o
+*.a
+mkmf.log
+gohttp.h
+gohttp.so

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (C) 2015 NARUSE, Yui. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,35 @@
+# Gohttp
+
+A demo to implement a extension library with Go.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gohttp'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gohttp
+
+## Usage
+
+```ruby
+require 'gohttp'
+r = Gohttp.get('https://example.com/index.html')
+puts r.body.read
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/nurse/gohttp/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+require 'rake/extensiontask'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => [:compile, :spec]
+
+spec = eval File.read('gohttp.gemspec')
+Rake::ExtensionTask.new('gohttp', spec) do |ext|
+  ext.ext_dir = 'ext/gohttp'
+  ext.lib_dir = File.join(*['lib', 'gohttp', ENV['FAT_DIR']].compact)
+  ext.source_pattern = "*.{c,cpp,go}"
+end
+
+RSpec::Core::RakeTask.new :spec  do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end

data/ext/gohttp/extconf.rb

@@ -0,0 +1,18 @@
+require 'mkmf'
+find_executable('go')
+$objs = []
+def $objs.empty?; false ;end
+create_makefile("gohttp/gohttp")
+case `#{CONFIG['CC']} --version`
+when /Free Software Foundation/
+  ldflags = '-Wl,--unresolved-symbols=ignore-all'
+when /clang/
+  ldflags = '-undefined dynamic_lookup'
+end
+File.open('Makefile', 'a') do |f|
+  f.write <<eom.gsub(/^ {8}/, "\t")
+$(DLLIB): Makefile $(srcdir)/gohttp.go $(srcdir)/wrapper.go
+        CGO_CFLAGS='$(INCFLAGS)' CGO_LDFLAGS='#{ldflags}' \
+          go build -p 4 -buildmode=c-shared -o $(DLLIB) $(srcdir)/gohttp.go $(srcdir)/wrapper.go
+eom
+end

data/ext/gohttp/gohttp.go

@@ -0,0 +1,362 @@
+package main
+
+/*
+#include <ruby/ruby.h>
+
+VALUE NewGoStruct(VALUE klass, void *p);
+void *GetGoStruct(VALUE obj);
+
+VALUE gohttp_hello(VALUE);
+VALUE gohttpGet(VALUE,VALUE);
+VALUE gohttpHead(VALUE,VALUE);
+int hash_of_ary_of_str2values_i(VALUE,VALUE,VALUE);
+VALUE gohttpPostForm(VALUE,VALUE,VALUE);
+VALUE gohttp_get_url(VALUE,VALUE);
+VALUE gourlQueryEscape(VALUE,VALUE);
+VALUE gourlQueryUnescape(VALUE,VALUE);
+
+VALUE goio_to_s(VALUE);
+VALUE goioRead(VALUE);
+VALUE goioClose(VALUE);
+
+VALUE reqMethod(VALUE);
+VALUE reqURL(VALUE);
+VALUE reqProto(VALUE);
+VALUE reqHeader(VALUE);
+VALUE reqBody(VALUE);
+VALUE reqContentLength(VALUE);
+VALUE reqTransferEncoding(VALUE);
+VALUE reqHost(VALUE);
+VALUE reqForm(VALUE);
+VALUE reqForm(VALUE);
+VALUE reqForm(VALUE);
+VALUE reqForm(VALUE);
+VALUE reqRemoteAddr(VALUE);
+VALUE reqRequestURI(VALUE);
+
+VALUE respContentLength(VALUE);
+VALUE respStatus(VALUE);
+VALUE respStatusCode(VALUE);
+VALUE respProto(VALUE);
+VALUE respTransferEncoding(VALUE);
+VALUE respHeader(VALUE);
+VALUE respBody(VALUE);
+VALUE respRequest(VALUE);
+*/
+import "C"
+
+import "fmt"
+import "io"
+import "io/ioutil"
+import "net/http"
+import "net/url"
+import "reflect"
+import "unsafe"
+
+func main() {
+}
+
+var rb_cGoIO C.VALUE
+var rb_cGohttp C.VALUE
+var rb_cGourl C.VALUE
+var rb_cRequest C.VALUE
+var rb_cResponse C.VALUE
+
+//export goobj_retain
+func goobj_retain(obj unsafe.Pointer) {
+	objects[obj] = true
+}
+
+//export goobj_free
+func goobj_free(obj unsafe.Pointer) {
+	delete(objects, obj)
+}
+
+func goioNew(klass C.VALUE, r interface{}) C.VALUE {
+	v := reflect.ValueOf(r)
+	return C.NewGoStruct(klass, unsafe.Pointer(&v))
+}
+
+//export goio_to_s
+func goio_to_s(self C.VALUE) C.VALUE {
+	v := (*reflect.Value)(C.GetGoStruct(self))
+	switch v.Kind() {
+	case reflect.Struct:
+		return RbString(fmt.Sprintf("#<GoIO:%s>", v.Type().String()))
+	case reflect.Chan, reflect.Map, reflect.Ptr, reflect.UnsafePointer:
+		return RbString(fmt.Sprintf("#<GoIO:%s:0x%X>", v.Type().String(), v.Pointer()))
+	default:
+		return RbString(fmt.Sprintf("#<GoIO:%s>", v.Type().String()))
+	}
+}
+
+//export goioRead
+func goioRead(self C.VALUE) C.VALUE {
+	v := (*reflect.Value)(C.GetGoStruct(self))
+	r := v.Interface().(io.Reader)
+	body, err := ioutil.ReadAll(r)
+	if err != nil {
+		rb_raise(C.rb_eArgError, "'%s'", err)
+	}
+	return RbBytes(body)
+}
+
+//export goioClose
+func goioClose(self C.VALUE) C.VALUE {
+	v := (*reflect.Value)(C.GetGoStruct(self))
+	if c, ok := v.Interface().(io.Closer); ok {
+		c.Close()
+		return C.Qtrue
+	}
+	return C.Qfalse
+}
+
+func reqNew(klass C.VALUE, r *http.Request) C.VALUE {
+	return C.NewGoStruct(klass, unsafe.Pointer(r))
+}
+
+//export reqMethod
+func reqMethod(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return RbString(req.Method)
+}
+
+//export reqProto
+func reqProto(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return RbString(req.Proto)
+}
+
+//export reqHeader
+func reqHeader(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	h := C.rb_hash_new()
+	for key, value := range req.Header {
+		C.rb_hash_aset(h, RbString(key), StrSlice2RbArray(value))
+	}
+	return h
+}
+
+//export reqBody
+func reqBody(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	if req.Body == nil {
+		return C.Qnil
+	}
+	return goioNew(rb_cGoIO, req.Body)
+}
+
+//export reqContentLength
+func reqContentLength(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return INT64toNUM(req.ContentLength)
+}
+
+//export reqTransferEncoding
+func reqTransferEncoding(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return StrSlice2RbArray(req.TransferEncoding)
+}
+
+//export reqHost
+func reqHost(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return RbString(req.Host)
+}
+
+//export reqRemoteAddr
+func reqRemoteAddr(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return RbString(req.RemoteAddr)
+}
+
+//export reqRequestURI
+func reqRequestURI(self C.VALUE) C.VALUE {
+	req := (*http.Request)(C.GetGoStruct(self))
+	return RbString(req.RequestURI)
+}
+
+func respNew(klass C.VALUE, r *http.Response) C.VALUE {
+	return C.NewGoStruct(klass, unsafe.Pointer(r))
+}
+
+//export respContentLength
+func respContentLength(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	return INT64toNUM(resp.ContentLength)
+}
+
+//export respHeader
+func respHeader(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	h := C.rb_hash_new()
+	for key, value := range resp.Header {
+		C.rb_hash_aset(h, RbString(key), StrSlice2RbArray(value))
+	}
+	return h
+}
+
+//export respStatus
+func respStatus(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	return RbString(resp.Status)
+}
+
+//export respStatusCode
+func respStatusCode(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	return INT2NUM(resp.StatusCode)
+}
+
+//export respProto
+func respProto(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	return RbString(resp.Proto)
+}
+
+//export respTransferEncoding
+func respTransferEncoding(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	return StrSlice2RbArray(resp.TransferEncoding)
+}
+
+//export respBody
+func respBody(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	if resp.Body == nil {
+		return C.Qnil
+	}
+	return goioNew(rb_cGoIO, resp.Body)
+}
+
+//export respRequest
+func respRequest(self C.VALUE) C.VALUE {
+	resp := (*http.Response)(C.GetGoStruct(self))
+	return reqNew(rb_cRequest, resp.Request)
+}
+
+//export gohttp_hello
+func gohttp_hello(dummy C.VALUE) C.VALUE {
+	fmt.Printf("hello, world\n")
+	return C.Qnil
+}
+
+//export gohttpGet
+func gohttpGet(dummy C.VALUE, urlstr C.VALUE) C.VALUE {
+	str := RbGoString(urlstr)
+	resp, err := http.Get(str)
+	if err != nil {
+		rb_raise(C.rb_eArgError, "'%s'", err)
+	}
+	return respNew(rb_cResponse, resp)
+}
+
+//export gohttpHead
+func gohttpHead(dummy C.VALUE, urlstr C.VALUE) C.VALUE {
+	str := RbGoString(urlstr)
+	resp, err := http.Head(str)
+	if err != nil {
+		rb_raise(C.rb_eArgError, "'%s'", err)
+	}
+	return respNew(rb_cResponse, resp)
+}
+
+//export hash_of_ary_of_str2values_i
+func hash_of_ary_of_str2values_i(key C.VALUE, ary C.VALUE, arg C.VALUE) C.int {
+	values := (*url.Values)(unsafe.Pointer(uintptr(arg)))
+	values.Add(RbGoString(key), RbGoString(ary))
+	return C.ST_CONTINUE
+}
+
+//export gohttpPostForm
+func gohttpPostForm(dummy C.VALUE, urlstr C.VALUE, data C.VALUE) C.VALUE {
+	str := RbGoString(urlstr)
+	val := url.Values{}
+	C.rb_hash_foreach(data, (*[0]byte)(C.hash_of_ary_of_str2values_i), C.VALUE(uintptr(unsafe.Pointer(&val))))
+	resp, err := http.PostForm(str, val)
+	if err != nil {
+		rb_raise(C.rb_eArgError, "'%s'", err)
+	}
+	return respNew(rb_cResponse, resp)
+}
+
+//export gohttp_get_url
+func gohttp_get_url(dummy C.VALUE, urlstr C.VALUE) C.VALUE {
+	u, err := url.Parse(RbGoString(urlstr))
+	if err != nil {
+		return C.Qnil
+	}
+	return RbString(u.String())
+}
+
+//export gourlQueryEscape
+func gourlQueryEscape(dummy C.VALUE, s C.VALUE) C.VALUE {
+	return RbString(url.QueryEscape(RbGoString(s)))
+}
+
+//export gourlQueryUnescape
+func gourlQueryUnescape(dummy C.VALUE, s C.VALUE) C.VALUE {
+	src := RbGoString(s)
+	str, err := url.QueryUnescape(src)
+	if err != nil {
+		rb_raise(C.rb_eArgError, "'%s' is not valid pct-encoded", src)
+	}
+	return RbString(str)
+}
+
+//export Init_gohttp
+func Init_gohttp() {
+	sNew := "new"
+	str_new := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&sNew)))[0]))
+
+	rb_cGoIO = rb_define_class("GoIO", C.rb_cIO)
+	C.rb_undef_alloc_func(rb_cGoIO)
+	C.rb_undef_method(C.rb_class_of(rb_cGoIO), str_new)
+	rb_define_method(rb_cGoIO, "to_s", C.goio_to_s, 0)
+	rb_define_method(rb_cGoIO, "inspect", C.goio_to_s, 0)
+	rb_define_method(rb_cGoIO, "read", C.goioRead, 0)
+	rb_define_method(rb_cGoIO, "close", C.goioClose, 0)
+
+	rb_cRequest = rb_define_class("Request", C.rb_cObject)
+	C.rb_undef_alloc_func(rb_cRequest)
+	C.rb_undef_method(C.rb_class_of(rb_cRequest), str_new)
+	rb_define_method(rb_cRequest, "method", C.reqMethod, 0)
+	//rb_define_method(rb_cRequest, "url", C.reqURL, 0)
+	rb_define_method(rb_cRequest, "proto", C.reqProto, 0)
+	rb_define_method(rb_cRequest, "header", C.reqHeader, 0)
+	rb_define_method(rb_cRequest, "body", C.reqBody, 0)
+	rb_define_method(rb_cRequest, "content_length", C.reqContentLength, 0)
+	rb_define_method(rb_cRequest, "transfer_encoding", C.reqTransferEncoding, 0)
+	rb_define_method(rb_cRequest, "host", C.reqHost, 0)
+	//rb_define_method(rb_cRequest, "form", C.reqForm, 0)
+	//rb_define_method(rb_cRequest, "post_form", C.reqForm, 0)
+	//rb_define_method(rb_cRequest, "multipart_form", C.reqForm, 0)
+	//rb_define_method(rb_cRequest, "trailer", C.reqForm, 0)
+	rb_define_method(rb_cRequest, "remote_addr", C.reqRemoteAddr, 0)
+	rb_define_method(rb_cRequest, "request_uri", C.reqRequestURI, 0)
+
+	rb_cResponse = rb_define_class("Response", C.rb_cObject)
+	C.rb_undef_alloc_func(rb_cResponse)
+	C.rb_undef_method(C.rb_class_of(rb_cResponse), str_new)
+	rb_define_method(rb_cResponse, "size", C.respContentLength, 0)
+	rb_define_method(rb_cResponse, "status", C.respStatus, 0)
+	rb_define_method(rb_cResponse, "status_code", C.respStatusCode, 0)
+	rb_define_method(rb_cResponse, "proto", C.respProto, 0)
+	rb_define_method(rb_cResponse, "transfer_encoding", C.respTransferEncoding, 0)
+	rb_define_method(rb_cResponse, "header", C.respHeader, 0)
+	rb_define_method(rb_cResponse, "body", C.respBody, 0)
+	rb_define_method(rb_cResponse, "request", C.respRequest, 0)
+
+	rb_cGohttp = rb_define_class("Gohttp", C.rb_cObject)
+	rb_define_singleton_method(rb_cGohttp, "hello", C.gohttp_hello, 0)
+	rb_define_singleton_method(rb_cGohttp, "get", C.gohttpGet, 1)
+	rb_define_singleton_method(rb_cGohttp, "head", C.gohttpHead, 1)
+	//rb_define_singleton_method(rb_cGohttp, "post", C.gohttpPost, 1)
+	rb_define_singleton_method(rb_cGohttp, "post_form", C.gohttpPostForm, 2)
+	//rb_define_method(rb_cGohttp, "initialize", C.gohttp_initialize, 1)
+	rb_define_method(rb_cGohttp, "get_url", C.gohttp_get_url, 1)
+
+	rb_cGourl = rb_define_class("Gourl", C.rb_cObject)
+	rb_define_singleton_method(rb_cGourl, "query_escape", C.gourlQueryEscape, 1)
+	rb_define_singleton_method(rb_cGourl, "query_unescape", C.gourlQueryUnescape, 1)
+}

data/ext/gohttp/wrapper.go

@@ -0,0 +1,105 @@
+package main
+
+/*
+#include <ruby/ruby.h>
+
+const char *
+rstring_ptr(VALUE str) {
+    return RSTRING_PTR(str);
+}
+int
+rstring_len(VALUE str) {
+    return RSTRING_LENINT(str);
+}
+void
+rb_raise2(VALUE exc, const char *str) {
+    rb_raise(exc, "%s", str);
+}
+
+void goobj_retain(void *);
+void goobj_free(void *);
+
+static const rb_data_type_t go_type = {
+    "GoStruct",
+    {NULL, goobj_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
+};
+
+VALUE
+NewGoStruct(VALUE klass, void *p)
+{
+    goobj_retain(p);
+    return TypedData_Wrap_Struct((klass), &go_type, p);
+}
+
+void *
+GetGoStruct(VALUE obj)
+{
+    void *val;
+    return TypedData_Get_Struct((obj), void *, &go_type, (val));
+}
+*/
+import "C"
+import "unsafe"
+import "fmt"
+
+var objects = make(map[interface{}]bool)
+
+func rb_define_method(klass C.VALUE, name string, fun unsafe.Pointer, args int) {
+	cname := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&name)))[0]))
+	C.rb_define_method(klass, cname, (*[0]byte)(fun), C.int(args))
+}
+
+func rb_define_singleton_method(klass C.VALUE, name string, fun unsafe.Pointer, args int) {
+	cname := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&name)))[0]))
+	C.rb_define_singleton_method(klass, cname, (*[0]byte)(fun), C.int(args))
+}
+
+func RbGoString(str C.VALUE) string {
+	C.rb_string_value(&str)
+	return C.GoStringN(C.rstring_ptr(str), C.rstring_len(str))
+}
+
+func RbBytes(bytes []byte) C.VALUE {
+	if len(bytes) == 0 {
+		return C.rb_str_new(nil, C.long(0))
+	}
+	cstr := (*C.char)(unsafe.Pointer(&bytes[0]))
+	return C.rb_str_new(cstr, C.long(len(bytes)))
+}
+
+func RbString(str string) C.VALUE {
+	if len(str) == 0 {
+		return C.rb_utf8_str_new(nil, C.long(0))
+	}
+	cstr := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&str)))[0]))
+	return C.rb_utf8_str_new(cstr, C.long(len(str)))
+}
+
+func rb_define_class(name string, parent C.VALUE) C.VALUE {
+	cname := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&name)))[0]))
+	v := C.rb_define_class(cname, parent)
+	return v
+}
+
+func rb_raise(exc C.VALUE, format string, a ...interface{}) {
+	str := fmt.Sprintf(format, a...)
+	cstr := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&str)))[0]))
+	C.rb_raise2(exc, cstr)
+}
+
+func INT2NUM(n int) C.VALUE {
+	return C.rb_int2inum(C.long(n))
+}
+
+func INT64toNUM(n int64) C.VALUE {
+	return C.rb_ll2inum(C.longlong(n))
+}
+
+func StrSlice2RbArray(slice []string) C.VALUE {
+	ary := C.rb_ary_new_capa(C.long(len(slice)))
+	for _, val := range slice {
+		C.rb_ary_push(ary, RbString(val))
+	}
+	return ary
+}

data/gohttp.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gohttp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gohttp"
+  spec.version       = Strptime::VERSION
+  spec.authors       = ["NARUSE, Yui"]
+  spec.email         = ["naruse@airemix.jp"]
+
+  spec.summary       = %q{an http library with go.}
+  spec.description   = %q{an http library with go.}
+  spec.homepage      = "https://github.com/nurse/gohttp"
+  spec.license       = "BSD-2-Clause"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/gohttp/extconf.rb"]
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'yard'
+end

data/lib/gohttp.rb

@@ -0,0 +1,10 @@
+require "gohttp/version"
+begin
+  require "gohttp/#{RUBY_VERSION[/\d+\.\d+/]}/gohttp"
+rescue LoadError
+  require "gohttp/gohttp"
+end
+
+class Gohttp
+  # Your code goes here...
+end

data/lib/gohttp/version.rb

@@ -0,0 +1,3 @@
+class Strptime
+    VERSION = "0.1.0"
+end

data/test.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+
+require 'gohttp'
+require 'minitest/autorun'
+
+class TestGohttp < Minitest::Test
+  def test_hello
+    assert_output("hello, world\n") do
+      Gohttp.hello
+    end
+  end
+
+  def test_hello
+    o = Object.new
+    def o.to_str; "https://例え.テスト/ファイル.html"; end
+    g = Gohttp.new
+    assert_equal "https://%E4%BE%8B%E3%81%88.%E3%83%86%E3%82%B9%E3%83%88/%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB.html", g.get_url(o)
+  end
+
+  def test_get
+    r = Gohttp.get('https://example.com/index.html')
+    assert_kind_of Response, r
+    assert_equal '200 OK', r.status
+    assert_equal 200, r.status_code
+    assert_equal 'HTTP/1.1', r.proto
+    assert_equal 1270, r.size
+    assert_equal [], r.transfer_encoding
+    hdr = r.header
+    assert_kind_of Hash, hdr
+    assert_equal %w[max-age=604800], hdr["Cache-Control"]
+    assert_equal %w[text/html], hdr["Content-Type"]
+    b = r.body
+    assert_match /\A#<GoIO:\*http.bodyEOFSignal:0x\h+>/, b.to_s
+    assert_match /Example Domain/, b.read
+    assert_equal true, b.close
+    req = r.request
+    assert_equal 'GET', req.method
+    assert_equal 'HTTP/1.1', req.proto
+    assert_equal Hash[], req.header
+    assert_nil req.body
+    assert_equal 0, req.content_length
+    assert_equal [], req.transfer_encoding
+    assert_equal 'example.com', req.host
+    assert_equal '', req.remote_addr
+    assert_equal '', req.request_uri
+  end
+
+  def test_head
+    r = Gohttp.head('https://example.com/index.html')
+    assert_kind_of Response, r
+    assert_equal '200 OK', r.status
+    assert_equal 200, r.status_code
+    assert_equal 'HTTP/1.1', r.proto
+    assert_equal 1270, r.size
+    assert_equal [], r.transfer_encoding
+    hdr = r.header
+    assert_kind_of Hash, hdr
+    assert_equal %w[max-age=604800], hdr["Cache-Control"]
+    assert_equal %w[text/html], hdr["Content-Type"]
+    b = r.body
+    assert_match /\A#<GoIO:\*http.bodyEOFSignal>/, b.to_s
+    assert_match '', b.read
+    assert_equal true, b.close
+    req = r.request
+    assert_equal 'HEAD', req.method
+    assert_equal 'HTTP/1.1', req.proto
+    assert_equal Hash[], req.header
+    assert_nil req.body
+    assert_equal 0, req.content_length
+    assert_equal [], req.transfer_encoding
+    assert_equal 'example.com', req.host
+    assert_equal '', req.remote_addr
+    assert_equal '', req.request_uri
+  end
+
+  def test_head
+    r = Gohttp.post_form('http://nalsh.jp/env.cgi', {'foo' => 'bar'})
+    assert_kind_of Response, r
+    assert_equal '200 OK', r.status
+    assert_equal 200, r.status_code
+    assert_equal 'HTTP/1.1', r.proto
+    assert_equal -1, r.size
+    assert_equal %w[chunked], r.transfer_encoding
+    hdr = r.header
+    assert_kind_of Hash, hdr
+    assert_equal nil, hdr["Cache-Control"]
+    assert_equal %w[text/html], hdr["Content-Type"]
+    b = r.body
+    assert_match /\A#<GoIO:\*http.bodyEOFSignal:0x\h+>/, b.to_s
+    assert_match '', b.read
+    assert_equal true, b.close
+    req = r.request
+    assert_equal 'POST', req.method
+    assert_equal 'HTTP/1.1', req.proto
+    assert_equal Hash["Content-Type"=>["application/x-www-form-urlencoded"]], req.header
+    assert_match /\A#<GoIO:ioutil.nopCloser>\z/, req.body.to_s
+    assert_equal 7, req.content_length
+    assert_equal [], req.transfer_encoding
+    assert_equal 'nalsh.jp', req.host
+    assert_equal '', req.remote_addr
+    assert_equal '', req.request_uri
+  end
+end
+
+class TestGourl < Minitest::Test
+  def test_escape
+    assert_equal '%E3%81%82+%2B',  Gourl.query_escape('あ +')
+  end
+
+  def test_escape
+    assert_equal 'あ  ', Gourl.query_unescape('%E3%81%82%20+')
+    assert_raises(ArgumentError){ Gourl.query_unescape('%%81%82%20+') }
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: gohttp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- NARUSE, Yui
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: an http library with go.
+email:
+- naruse@airemix.jp
+executables: []
+extensions:
+- ext/gohttp/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/gohttp/extconf.rb
+- ext/gohttp/gohttp.go
+- ext/gohttp/wrapper.go
+- gohttp.gemspec
+- lib/gohttp.rb
+- lib/gohttp/version.rb
+- test.rb
+homepage: https://github.com/nurse/gohttp
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: an http library with go.
+test_files: []
+has_rdoc: