jruby-http-kit 0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'rubygems'
+require 'webmachine'
+require 'http_kit'
+require 'rspec'
+require 'logger'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/test_resource.rb

@@ -0,0 +1,75 @@
+require "webmachine"
+
+module Test
+  class Resource < ::Webmachine::Resource
+    def allowed_methods
+      ["GET", "PUT", "POST"]
+    end
+
+    def content_types_accepted
+      [
+        ["test/request.stringbody", :from_string],
+        ["test/request.enumbody", :from_enum]
+      ]
+    end
+
+    def content_types_provided
+      [
+        ["test/response.stringbody", :to_string],
+        ["test/response.enumbody", :to_enum],
+        ["test/response.procbody", :to_proc],
+        ["test/response.fiberbody", :to_fiber],
+        ["test/response.iobody", :to_io],
+        ["test/response.cookies", :to_cookies]
+      ]
+    end
+
+    def from_string
+      response.body = "String: #{request.body.to_s}"
+    end
+
+    def from_enum
+      response.body = "Enum: "
+      request.body.each do |part|
+        response.body += part
+      end
+    end
+
+    # Response intentionally left blank to test 204 support
+    def process_post
+      true
+    end
+
+    def to_string
+      "String response body"
+    end
+
+    def to_enum
+      ["Enumerable ", "response " "body"]
+    end
+
+    def to_proc
+      Proc.new { "Proc response body" }
+    end
+
+    def to_fiber
+      Fiber.new do
+        Fiber.yield "Fiber "
+        Fiber.yield "response "
+        "body"
+      end
+    end
+
+    def to_io
+      StringIO.new("IO response body")
+    end
+
+    def to_cookies
+      response.set_cookie("cookie", "monster")
+      response.set_cookie("rodeo", "clown")
+      # FIXME: Mongrel/WEBrick fail if this method returns nil
+      # Might be a net/http issue. Is this a bug?
+      request.cookies["echo"] || ""
+    end
+  end
+end

data/spec/webmachine/ring_adapter_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+require "webmachine/adapters/ring"
+require "support/test_resource"
+require "net/http"
+
+describe "Webmachine::Adapters::Ring" do
+  attr_accessor :client
+
+  before(:all) do
+    configuration = Webmachine::Configuration.default
+    dispatcher = Webmachine::Dispatcher.new
+    dispatcher.add_route ["test"], Test::Resource
+
+    @adapter = Webmachine::Adapters::Ring.new(configuration, dispatcher)
+    @client = Net::HTTP.new(configuration.ip, configuration.port)
+
+    Thread.abort_on_exception = true
+    @server_thread = Thread.new { @adapter.run }
+
+    # Wait until the server is responsive
+    timeout(5) do
+      begin
+        client.start
+      rescue Errno::ECONNREFUSED
+        sleep(0.1)
+        retry
+      end
+    end
+  end
+
+  after(:all) do
+    @adapter.shutdown
+    @client.finish
+    @server_thread.join
+  end
+
+  it "provides a string-like request body" do
+    request = Net::HTTP::Put.new("/test")
+    request.body = "Hello, World!"
+    request["Content-Type"] = "test/request.stringbody"
+    response = client.request(request)
+    response["Content-Length"].should eq("21")
+    response.body.should eq("String: Hello, World!")
+  end
+
+  it "provides an enumerable request body" do
+    request = Net::HTTP::Put.new("/test")
+    request.body = "Hello, World!"
+    request["Content-Type"] = "test/request.enumbody"
+    response = client.request(request)
+    response["Content-Length"].should eq("19")
+    response.body.should eq("Enum: Hello, World!")
+  end
+
+  it "handles missing pages" do
+    request = Net::HTTP::Get.new("/missing")
+    response = client.request(request)
+    response.code.should eq("404")
+    response["Content-Type"].should eq("text/html")
+  end
+
+  it "handles empty response bodies" do
+    request = Net::HTTP::Post.new("/test")
+    request.body = ""
+    response = client.request(request)
+    response.code.should eq("204")
+    # FIXME: Mongrel/WEBrick fail this test. Is there a bug?
+    #response["Content-Type"].should be_nil
+    response["Content-Length"].should be_nil
+    response.body.should be_nil
+  end
+
+  it "handles string response bodies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.stringbody"
+    response = client.request(request)
+    response["Content-Length"].should eq("20")
+    response.body.should eq("String response body")
+  end
+
+  it "handles enumerable response bodies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.enumbody"
+    response = client.request(request)
+    response["Transfer-Encoding"].should eq("chunked")
+    response.body.should eq("Enumerable response body")
+  end
+
+  it "handles proc response bodies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.procbody"
+    response = client.request(request)
+    response["Transfer-Encoding"].should eq("chunked")
+    response.body.should eq("Proc response body")
+  end
+
+  it "handles fiber response bodies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.fiberbody"
+    response = client.request(request)
+    response["Transfer-Encoding"].should eq("chunked")
+    response.body.should eq("Fiber response body")
+  end
+
+  it "handles io response bodies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.iobody"
+    response = client.request(request)
+    response["Content-Length"].should eq("16")
+    response.body.should eq("IO response body")
+  end
+
+  it "handles request cookies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.cookies"
+    request["Cookie"] = "echo=echocookie"
+    response = client.request(request)
+    response.body.should eq("echocookie")
+  end
+
+  it "handles response cookies" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.cookies"
+    response = client.request(request)
+    response["Set-Cookie"].should eq("cookie=monster, rodeo=clown")
+  end
+end

data/src/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path=""/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="/Users/drozhkov/Downloads/clojure-1.5.1/clojure-1.5.1.jar"/>
+	<classpathentry kind="output" path=""/>
+</classpath>

data/src/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>httpkit</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

data/src/org/httpkit/BytesInputStream.java

@@ -0,0 +1,83 @@
+package org.httpkit;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+/**
+ * No synchronization, better toString
+ */
+public class BytesInputStream extends InputStream {
+    private final byte[] buf;
+    private final int count;
+    private int mark = 0;
+
+    private int pos;
+
+    public BytesInputStream(byte[] data, int length) {
+        this.buf = data;
+        this.count = length;
+        this.pos = 0;
+    }
+
+    /**
+     * get the underlying bytes, copied
+     *
+     * @return
+     */
+    public byte[] bytes() {
+        return Arrays.copyOf(buf, count);
+    }
+
+    public int read() throws IOException {
+        return (pos < count) ? (buf[pos++] & 0xff) : -1;
+    }
+
+    public int read(byte[] b) throws IOException {
+        return read(b, 0, b.length);
+    }
+
+    public int read(byte[] b, int off, int len) throws IOException {
+        if (pos >= count) {
+            return -1;
+        }
+
+        int avail = count - pos;
+        if (len > avail) {
+            len = avail;
+        }
+
+        System.arraycopy(buf, pos, b, off, len);
+        pos += len;
+        return len;
+    }
+
+    public String toString() {
+        return "BytesInputStream[len=" + count + "]";
+    }
+
+    public long skip(long n) throws IOException {
+        long k = count - pos;
+        if (n < k) {
+            k = n < 0 ? 0 : n;
+        }
+        pos += k;
+        return k;
+    }
+
+    public int available() {
+        return count - pos;
+    }
+
+    public boolean markSupported() {
+        return true;
+    }
+
+    public void mark(int readAheadLimit) {
+        mark = pos;
+    }
+
+    public void reset() {
+        pos = mark;
+    }
+}

data/src/org/httpkit/DynamicBytes.java

@@ -0,0 +1,76 @@
+package org.httpkit;
+
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+public class DynamicBytes {
+    private byte[] data;
+    private int idx = 0;
+
+    public DynamicBytes(int size) {
+        data = new byte[size];
+    }
+
+    private void expandIfNeeded(int more) {
+        if (idx + more > data.length) {
+            int after = (int) ((idx + more) * 1.33);
+            // String msg = "expand memory, from " + data.length + " to " +
+            // after + "; need " + more;
+            // System.out.println(msg);
+            data = Arrays.copyOf(data, after);
+        }
+    }
+
+    public byte[] get() {
+        return data;
+    }
+
+    public int length() {
+        return idx;
+    }
+
+    public DynamicBytes append(byte b) {
+        expandIfNeeded(1);
+        data[idx++] = b;
+        return this;
+    }
+
+    public void append(byte b1, byte b2) {
+        expandIfNeeded(2);
+        data[idx++] = b1;
+        data[idx++] = b2;
+    }
+
+    @Override
+    public String toString() {
+        return "DynamicBytes[len=" + idx + ", cap=" + data.length + ']';
+    }
+
+    public DynamicBytes append(byte[] d, int length) {
+        expandIfNeeded(length);
+        System.arraycopy(d, 0, data, idx, length);
+        idx += length;
+        return this;
+    }
+
+    public DynamicBytes append(String str) {
+        // ISO-8859-1. much faster than String.getBytes("ISO-8859-1")
+        // less copy. 620ms vs 190ms
+        int length = str.length();
+        expandIfNeeded(length);
+        for (int i = 0; i < length; i++) {
+            char c = str.charAt(i);
+            if (c < 128) {
+                data[idx++] = (byte) c;
+            } else {
+                data[idx++] = (byte) '?'; // JDK uses ? to represent non ASCII
+            }
+        }
+        return this;
+    }
+
+    public DynamicBytes append(String str, Charset c) {
+        byte[] bs = str.getBytes(c);
+        return append(bs, bs.length);
+    }
+}

data/src/org/httpkit/HTTPException.java

@@ -0,0 +1,10 @@
+package org.httpkit;
+
+public class HTTPException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    public HTTPException(String msg) {
+        super(msg);
+    }
+}

data/src/org/httpkit/HeaderMap.java

@@ -0,0 +1,98 @@
+package org.httpkit;
+
+import clojure.lang.ISeq;
+import clojure.lang.Seqable;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import static org.httpkit.HttpUtils.*;
+
+/**
+ * Save a few bytes of memory => No Map.Entry, and a little faster
+ * Date: 4/23/13
+ *
+ * @author feng <shenedu@gmail.com>
+ * @since 2.0.2
+ */
+public class HeaderMap {
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public final int INIT_SIZE = 8;
+
+    private int size = 0;
+    private Object arrays[] = new Object[INIT_SIZE * 2];
+
+    public void put(String key, Object obj) {
+        final int total = size << 1;
+        if (total == arrays.length) {
+            arrays = Arrays.copyOf(arrays, arrays.length * 2);
+        }
+        arrays[total] = key;
+        arrays[total + 1] = obj;
+        size += 1;
+    }
+
+    public Object get(String key) {
+        final int total = size << 1; // * 2
+        for (int i = 0; i < total; i += 2) {
+            if (key.equals(arrays[i])) {
+                return arrays[i + 1];
+            }
+        }
+        return null;
+    }
+
+    public boolean containsKey(String key) {
+        final int total = size << 1; // * 2
+        for (int i = 0; i < total; i += 2) {
+            if (key.equals(arrays[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void clear() {
+        this.size = 0;
+    }
+
+    public static HeaderMap camelCase(Map<String, Object> map) {
+        HeaderMap tmp = new HeaderMap();
+        if (map != null) {
+            for (Map.Entry<String, Object> e : map.entrySet()) {
+                tmp.put(HttpUtils.camelCase(e.getKey()), e.getValue());
+            }
+        }
+        return tmp;
+    }
+
+    public void encodeHeaders(DynamicBytes bytes) {
+        final int total = size << 1;
+        for (int i = 0; i < total; i += 2) {
+            String k = (String) arrays[i];
+            Object v = arrays[i + 1];
+            if (v instanceof String) {
+                bytes.append(k);
+                bytes.append(COLON, SP);
+                // supposed to be ISO-8859-1, but utf-8 is compatible.
+                // filename in Content-Disposition can be utf8
+                bytes.append((String) v, HttpUtils.UTF_8);
+                bytes.append(CR, LF);
+                // ring spec says it could be a seq
+            } else if (v instanceof Seqable) {
+                ISeq seq = ((Seqable) v).seq();
+                while (seq != null) {
+                    bytes.append(k);
+                    bytes.append(COLON, SP);
+                    bytes.append(seq.first().toString(), HttpUtils.UTF_8);
+                    bytes.append(CR, LF);
+                    seq = seq.next();
+                }
+            }
+        }
+        bytes.append(CR, LF);
+    }
+}

data/src/org/httpkit/HttpMethod.java

@@ -0,0 +1,28 @@
+package org.httpkit;
+
+import clojure.lang.Keyword;
+
+import static clojure.lang.Keyword.intern;
+
+public enum HttpMethod {
+
+    GET(intern("get")), HEAD(intern("head")), POST(intern("post")), PUT(intern("put")),
+    DELETE(intern("delete")), TRACE(intern("trace")), OPTIONS(intern("options")),
+    CONNECT(intern("connect")), PATCH(intern("patch"));
+
+    public final Keyword KEY;
+
+    private HttpMethod(Keyword key) {
+        this.KEY = key;
+    }
+
+    public static HttpMethod fromKeyword(Keyword k) {
+        HttpMethod[] values = HttpMethod.values();
+        for (HttpMethod m : values) {
+            if (m.KEY.equals(k)) {
+                return m;
+            }
+        }
+        throw new RuntimeException("unsupported method " + k);
+    }
+}