webmachine 1.6.0 → 2.0.0.beta

data/lib/webmachine/adapters/httpkit.rb

@@ -1,74 +0,0 @@
-require 'webmachine/adapter'
-require 'webmachine/constants'
-require 'webmachine/version'
-require 'httpkit'
-require 'webmachine/version'
-require 'webmachine/response'
-require 'webmachine/request'
-require 'webmachine/headers'
-
-module Webmachine
-  module Adapters
-    class HTTPkit < Adapter
-      VERSION_STRING = "#{Webmachine::SERVER_STRING} HTTPkit/#{::HTTPkit::VERSION}".freeze
-
-      def options
-        @options ||= {
-          :address => application.configuration.ip,
-          :port => application.configuration.port,
-          :handlers => [
-            ::HTTPkit::Server::TimeoutsHandler.new,
-            ::HTTPkit::Server::KeepAliveHandler.new,
-            self
-          ]
-        }
-      end
-
-      def run
-        ::HTTPkit.start do
-          ::HTTPkit::Server.start(options)
-        end
-      end
-
-      # Called by HTTPkit::Server for every request
-      def serve(request, served)
-        response = Webmachine::Response.new
-        application.dispatcher.dispatch(convert_request(request), response)
-
-        served.fulfill(convert_response(response))
-      end
-
-      private
-
-      # Converts HTTPkit::Request to Webmachine::Request
-      def convert_request(request)
-        Webmachine::Request.new(
-          request.http_method.to_s.upcase,
-          request.uri,
-          Webmachine::Headers[request.headers.dup],
-          request.body)
-      end
-
-      # Converts Webmachine::Response to HTTPkit::Response
-      def convert_response(response)
-        response.headers[SERVER] = VERSION_STRING
-
-
-        ::HTTPkit::Response.new(
-          response.code.to_i,
-          response.headers,
-          convert_body(response.body))
-      end
-
-      # HTTPkit::Body accepts strings and enumerables, i.e. Webmachine's
-      # Callable, Enumerable, IO, and Fiber encoders are supported.
-      def convert_body(body)
-        if body.respond_to?(:call)
-          [body.call]
-        else
-          body || ''
-        end
-      end
-    end
-  end
-end

data/lib/webmachine/adapters/reel.rb

@@ -1,113 +0,0 @@
-require 'webmachine/adapter'
-require 'webmachine/constants'
-require 'set'
-require 'celluloid/current'
-require 'reel'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-
-module Webmachine
-  module Adapters
-    class Reel < Adapter
-      # Used to override default Reel server options (useful in testing)
-      DEFAULT_OPTIONS = {}
-
-      def run
-        @options = DEFAULT_OPTIONS.merge({
-          :port => application.configuration.port,
-          :host => application.configuration.ip
-        }).merge(application.configuration.adapter_options)
-
-        if extra_verbs = application.configuration.adapter_options[:extra_verbs]
-          @extra_verbs = Set.new(extra_verbs.map(&:to_s).map(&:upcase))
-        else
-          @extra_verbs = Set.new
-        end
-
-        if @options[:ssl]
-          unless @options[:ssl][:cert] && @options[:ssl][:key]
-            raise ArgumentError, 'Certificate or Private key missing for HTTPS Server'
-          end
-          @server = ::Reel::Server::HTTPS.supervise(@options[:host], @options[:port], @options[:ssl], &method(:process))
-        else
-          @server = ::Reel::Server::HTTP.supervise(@options[:host], @options[:port], &method(:process))
-        end
-
-        Celluloid::Actor.join(@server)
-      end
-
-      def process(connection)
-        connection.each_request do |request|
-          # Users of the adapter can configure a custom WebSocket handler
-          if request.websocket?
-            if handler = @options[:websocket_handler]
-              handler.call(request.websocket)
-            else
-              # Pretend we don't know anything about the WebSocket protocol
-              # FIXME: This isn't strictly what RFC 6455 would have us do
-              request.respond :bad_request, "WebSockets not supported"
-            end
-
-            next
-          end
-
-          # Optional support for e.g. WebDAV verbs not included in Webmachine's
-          # state machine. Do the "Railsy" thing and handle them like POSTs
-          # with a magical parameter
-          if @extra_verbs.include?(request.method)
-            method = POST_METHOD
-            param  = "_method=#{request.method}"
-            uri    = request_uri(request.url, request.headers, param)
-          else
-            method = request.method
-            uri    = request_uri(request.url, request.headers)
-          end
-
-          wm_headers  = Webmachine::Headers[request.headers.dup]
-          wm_request  = Webmachine::Request.new(method, uri, wm_headers, request.body)
-
-          wm_response = Webmachine::Response.new
-          application.dispatcher.dispatch(wm_request, wm_response)
-
-          fixup_headers(wm_response)
-          fixup_callable_encoder(wm_response)
-
-          request.respond ::Reel::Response.new(wm_response.code,
-                                               wm_response.headers,
-                                               wm_response.body)
-        end
-      end
-
-      def request_uri(path, headers, extra_query_params = nil)
-        path_parts = path.split('?')
-        uri_hash = {path: path_parts.first}
-        uri_hash[:query] = path_parts.last if path_parts.length == 2
-
-        if extra_query_params
-          if uri_hash[:query]
-            uri_hash[:query] << "&#{extra_query_params}"
-          else
-            uri_hash[:query] = extra_query_params
-          end
-        end
-
-        URI::HTTP.build(uri_hash)
-      end
-
-      def fixup_headers(response)
-        response.headers.each do |key, value|
-          if value.is_a?(Array)
-            response.headers[key] = value.join(", ")
-          end
-        end
-      end
-
-      def fixup_callable_encoder(response)
-        if response.body.is_a?(Streaming::CallableEncoder)
-          response.body = [response.body.call]
-        end
-      end
-    end
-  end
-end

data/memory_test.rb

@@ -1,37 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-require 'webmachine'
-
-class Constantized < Webmachine::Resource
-  HELLO_WORLD = "Hello World".freeze
-  ALLOWED_METHODS = ['GET'.freeze].freeze
-  CONTENT_TYPES_PROVIDED = [['text/html'.freeze, :to_html].freeze].freeze
-
-  def allowed_methods
-    ALLOWED_METHODS
-  end
-
-  def content_types_provided
-    CONTENT_TYPES_PROVIDED
-  end
-
-  def to_html
-    HELLO_WORLD
-  end
-end
-
-Webmachine.application.routes do
-  add ['constantized'], Constantized
-end
-
-require 'webmachine/test'
-session = Webmachine::Test::Session.new(Webmachine.application)
-CONSTANTIZED = '/constantized'.freeze
-require 'memory_profiler'
-report = MemoryProfiler.report do
-  100.times do
-    session.get(CONSTANTIZED)
-  end
-end
-
-report.pretty_print
-

data/spec/spec_helper.rb

@@ -1,56 +0,0 @@
-require "bundler/setup"
-Bundler.require :default, :test, :webservers
-require 'logger'
-
-class NullLogger < Logger
-  def add(severity, message=nil, progname=nil, &block)
-  end
-end
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-  config.filter_run :focus => true
-  config.run_all_when_everything_filtered = true
-  config.formatter = :documentation if ENV['CI']
-  if defined?(::Java)
-    config.seed = Time.now.utc
-  else
-    config.order = :random
-  end
-
-  config.before :each do
-    Webmachine::RescuableException.remove(RSpec::Mocks::MockExpectationError)
-  end
-
-  config.after :each do
-    Webmachine::RescuableException.default!
-  end
-
-  config.before(:suite) do
-    options = {
-      :Logger => NullLogger.new(STDERR),
-      :AccessLog => []
-    }
-    Webmachine::Adapters::WEBrick::DEFAULT_OPTIONS.merge! options
-    Webmachine::Adapters::Rack::DEFAULT_OPTIONS.merge! options if defined?(Webmachine::Adapters::Rack)
-  end
-end
-
-# For use in specs that need a fully initialized resource
-shared_context "default resource" do
-  let(:method) { 'GET' }
-  let(:uri) { URI.parse("http://localhost/") }
-  let(:headers) { Webmachine::Headers.new }
-  let(:body) { "" }
-  let(:request) { Webmachine::Request.new(method, uri, headers, body) }
-  let(:response) { Webmachine::Response.new }
-
-  let(:resource_class) do
-    Class.new(Webmachine::Resource) do
-      def to_html
-        "<html><body>Hello, world!</body></html>"
-      end
-    end
-  end
-  let(:resource) { resource_class.new(request, response) }
-end

data/spec/webmachine/adapter_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe Webmachine::Adapter do
-  let(:application) { Webmachine::Application.new }
-  let(:adapter) do
-    server = TCPServer.new('0.0.0.0', 0)
-    application.configuration.port = server.addr[1]
-    server.close
-
-    described_class.new(application)
-  end
-
-  describe "#initialize" do
-    it "stores the provided application" do
-      expect(adapter.application).to eq(application)
-    end
-  end
-
-  describe ".run" do
-    it "creates a new adapter and runs it" do
-      adapter = double(described_class)
-
-      expect(described_class).to receive(:new).
-        with(application).
-        and_return(adapter)
-
-      expect(adapter).to receive(:run)
-
-      described_class.run(application)
-    end
-  end
-
-  describe "#run" do
-    it "raises a NotImplementedError" do
-      expect { adapter.run }.to raise_exception(NotImplementedError)
-    end
-  end
-
-end

data/spec/webmachine/adapters/httpkit_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-require "webmachine/spec/adapter_lint"
-
-begin
-  describe Webmachine::Adapters::HTTPkit do
-    it_should_behave_like :adapter_lint
-  end
-rescue LoadError
-  warn "Platform is #{RUBY_PLATFORM}: skipping httpkit adapter spec."
-end

data/spec/webmachine/adapters/rack_mapped_spec.rb

@@ -1,71 +0,0 @@
-require 'webmachine/adapter'
-require 'webmachine/adapters/rack_mapped'
-require 'spec_helper'
-require 'webmachine/spec/adapter_lint'
-require 'rack/test'
-
-describe Webmachine::Adapters::RackMapped do
-  it_should_behave_like :adapter_lint do
-    it "should set Server header" do
-      response = client.request(Net::HTTP::Get.new("/test"))
-      expect(response["Server"]).to match(/Webmachine/)
-      expect(response["Server"]).to match(/Rack/)
-    end
-  end
-end
-
-describe Webmachine::Adapters::RackMapped do
-  class CreateResource < Webmachine::Resource
-    def allowed_methods
-      ["POST"]
-    end
-
-    def content_types_accepted
-      [["application/json", :from_json]]
-    end
-
-    def content_types_provided
-      [["application/json", :to_json]]
-    end
-
-    def post_is_create?
-      true
-    end
-
-    def create_path
-      "created_path_here/123"
-    end
-
-    def from_json
-      response.body = %{ {"foo": "bar"} }
-    end
-  end
-
-  let(:app) do
-    Rack::Builder.new do
-      map '/some/route' do
-        run(Webmachine::Application.new do |app|
-          app.add_route(["test"], Test::Resource)
-          app.add_route(["create_test"], CreateResource)
-          app.configure do | config |
-            config.adapter = :RackMapped
-          end
-        end.adapter)
-      end
-    end
-  end
-
-  context "using Rack::Test" do
-    include Rack::Test::Methods
-
-    it "provides the full request URI" do
-      rack_response = get "some/route/test", nil, {"HTTP_ACCEPT" => "test/response.request_uri"}
-      expect(rack_response.body).to eq "http://example.org/some/route/test"
-    end
-
-    it "provides LOCATION header using custom base_uri when creating from POST request" do
-      rack_response = post "/some/route/create_test", %{{"foo": "bar"}}, {"HTTP_ACCEPT" => "application/json", "CONTENT_TYPE" => "application/json"}
-      expect(rack_response.headers["Location"]).to eq("http://example.org/some/route/created_path_here/123")
-    end
-  end
-end

data/spec/webmachine/adapters/rack_spec.rb

@@ -1,62 +0,0 @@
-require 'webmachine/adapter'
-require 'webmachine/adapters/rack'
-require 'spec_helper'
-require 'webmachine/spec/adapter_lint'
-require 'rack/test'
-
-describe Webmachine::Adapters::Rack do
-  it_should_behave_like :adapter_lint do
-    it "should set Server header" do
-      response = client.request(Net::HTTP::Get.new("/test"))
-      expect(response["Server"]).to match(/Webmachine/)
-      expect(response["Server"]).to match(/Rack/)
-    end
-  end
-end
-
-describe Webmachine::Adapters::Rack::RackResponse do
-  context "on Rack < 1.5 release" do
-    before { allow(Rack).to receive_messages(:release => "1.4") }
-
-    it "should add Content-Type header on not acceptable response" do
-      rack_response = described_class.new(double(:body), 406, {})
-      rack_status, rack_headers, rack_body = rack_response.finish
-      expect(rack_headers).to have_key("Content-Type")
-    end
-  end
-
-  context "on Rack >= 1.5 release" do
-    before { allow(Rack).to receive_messages(:release => "1.5") }
-
-    it "should not add Content-Type header on not acceptable response" do
-      rack_response = described_class.new(double(:body), 406, {})
-      rack_status, rack_headers, rack_body = rack_response.finish
-      expect(rack_headers).not_to have_key("Content-Type")
-    end
-  end
-end
-
-describe Webmachine::Adapters::Rack do
-  let(:app) do
-    Webmachine::Application.new do |app|
-      app.add_route(["test"], Test::Resource)
-      app.configure do | config |
-        config.adapter = :Rack
-      end
-    end.adapter
-  end
-
-  context "using Rack::Test" do
-    include Rack::Test::Methods
-
-    it "provides the full request URI" do
-      rack_response = get "test", nil, {"HTTP_ACCEPT" => "test/response.request_uri"}
-      expect(rack_response.body).to eq "http://example.org/test"
-    end
-
-    it "provides the rack env on the request" do
-      rack_response = get "test", nil, {"HTTP_ACCEPT" => "test/response.rack_env"}
-      expect(JSON.parse(rack_response.body).keys).to include "rack.input"
-    end
-  end
-end

data/spec/webmachine/adapters/reel_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-require 'webmachine/spec/adapter_lint'
-describe Webmachine::Adapters::Reel do
-  context 'lint' do
-    it_should_behave_like :adapter_lint
-  end
-
-  context 'websockets' do
-    let(:application) { Webmachine::Application.new }
-    let(:adapter) do
-      server = TCPServer.new('0.0.0.0', 0)
-      application.configuration.port = server.addr[1]
-      server.close
-      described_class.new(application)
-    end
-
-    let(:example_host)    { "www.example.com" }
-    let(:example_path)    { "/example"}
-    let(:example_url)     { "ws://#{example_host}#{example_path}" }
-    let :handshake_headers do
-      {
-        "Host"                   => example_host,
-        "Upgrade"                => "websocket",
-        "Connection"             => "Upgrade",
-        "Sec-WebSocket-Key"      => "dGhlIHNhbXBsZSBub25jZQ==",
-        "Origin"                 => "http://example.com",
-        "Sec-WebSocket-Protocol" => "chat, superchat",
-        "Sec-WebSocket-Version"  => "13"
-      }
-    end
-    let(:client_message) { "Hi server!" }
-    let(:server_message) { "Hi client!" }
-
-    it 'supports websockets' do
-      application.configuration.adapter_options[:websocket_handler] = proc do |socket|
-        expect(socket.read).to eq client_message
-        socket << server_message
-      end
-
-      reel_server(adapter) do |client|
-        client << WebSocket::ClientHandshake.new(:get, example_url, handshake_headers).to_data
-
-        # Discard handshake response
-        # FIXME: hax
-        client.readpartial(4096)
-
-        client << WebSocket::Message.new(client_message).to_data
-        parser = WebSocket::Parser.new
-        parser.append client.readpartial(4096) until message = parser.next_message
-
-        expect(message).to eq server_message
-      end
-    end
-  end
-
-  def reel_server(adptr = adapter)
-    thread = Thread.new { adptr.run }
-    begin
-      Timeout.timeout(5) do
-        begin
-          sock = TCPSocket.new(adptr.application.configuration.ip, adptr.application.configuration.port)
-          begin
-            yield(sock)
-          ensure
-            sock.close
-          end
-        rescue Errno::ECONNREFUSED
-          Thread.pass
-          retry
-        end
-      end
-    ensure
-      thread.kill if thread
-    end
-  end
-end

data/spec/webmachine/adapters/webrick_spec.rb

@@ -1,12 +0,0 @@
-require "spec_helper"
-require "webmachine/spec/adapter_lint"
-
-describe Webmachine::Adapters::WEBrick do
-  it_should_behave_like :adapter_lint do
-    it "should set Server header" do
-      response = client.request(Net::HTTP::Get.new("/test"))
-      expect(response["Server"]).to match(/Webmachine/)
-      expect(response["Server"]).to match(/WEBrick/)
-    end
-  end
-end

data/spec/webmachine/application_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Application do
-  let(:application) { described_class.new }
-  let(:test_resource) { Class.new(Webmachine::Resource) }
-
-  it "accepts a Configuration when initialized" do
-    config = Webmachine::Configuration.new('1.1.1.1', 9999, :Reel, {})
-    expect(described_class.new(config).configuration).to be(config)
-  end
-
-  it "is yielded into a block provided during initialization" do
-    yielded_app = nil
-    returned_app = described_class.new do |app|
-      expect(app).to be_kind_of(Webmachine::Application)
-      yielded_app = app
-    end
-    expect(returned_app).to be(yielded_app)
-  end
-
-  it "is initialized with the default Configration if none is given" do
-    expect(application.configuration).to eq(Webmachine::Configuration.default)
-  end
-
-  it "returns the receiver from the configure call so you can chain it" do
-    expect(application.configure { |c| }).to equal(application)
-  end
-
-  it "is configurable" do
-    application.configure do |config|
-      expect(config).to be_kind_of(Webmachine::Configuration)
-    end
-  end
-
-  it "is initialized with an empty Dispatcher" do
-    expect(application.dispatcher.routes).to be_empty
-  end
-
-  it "can have routes added" do
-    route = nil
-    resource = test_resource # overcome instance_eval :/
-
-    expect(application.routes).to be_empty
-
-    application.routes do
-      route = add [:*], resource
-    end
-
-    expect(route).to be_kind_of(Webmachine::Dispatcher::Route)
-    expect(application.routes).to eq([route])
-  end
-
-  describe "#adapter" do
-    let(:adapter_class) { application.adapter_class }
-
-    it "returns an instance of it's adapter class" do
-      expect(application.adapter).to be_an_instance_of(adapter_class)
-    end
-
-    it "is memoized" do
-      expect(application.adapter).to eql application.adapter
-    end
-  end
-
-  it "can be run" do
-    expect(application.adapter).to receive(:run)
-    application.run
-  end
-
-  it "can be queried about its configured adapter" do
-    expected = Webmachine::Adapters.const_get(application.configuration.adapter)
-    expect(application.adapter_class).to equal(expected)
-  end
-end

data/spec/webmachine/chunked_body_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'webmachine/chunked_body'
-
-describe Webmachine::ChunkedBody do
-  it "builds a proper body" do
-    body = ''
-    Webmachine::ChunkedBody.new(['foo', 'bar', '', 'j', 'webmachine']).each do |chunk|
-      body << chunk
-    end
-    expect(body).to eq("3\r\nfoo\r\n3\r\nbar\r\n1\r\nj\r\na\r\nwebmachine\r\n0\r\n\r\n")
-  end
-
-  context "with an empty body" do
-    it "builds a proper body" do
-      body = ''
-      Webmachine::ChunkedBody.new([]).each do |chunk|
-        body << chunk
-      end
-      expect(body).to eq("0\r\n\r\n")
-    end
-  end
-
-  describe "#each" do
-    context "without a block given" do
-      it "returns an Enumerator" do
-        expect(Webmachine::ChunkedBody.new([]).each).to respond_to(:next)
-      end
-    end
-  end
-end

data/spec/webmachine/configuration_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Configuration do
-  before { Webmachine.configuration = nil }
-
-  %w{ip port adapter adapter_options}.each do |field|
-    it { is_expected.to respond_to(field) }
-    it { is_expected.to respond_to("#{field}=") }
-  end
-
-  it "should yield configuration to the block" do
-    Webmachine.configure do |config|
-      expect(config).to be_kind_of(described_class)
-    end
-  end
-
-  it "should set the global configuration from the yielded instance" do
-    Webmachine.configure do |config|
-      @config = config
-    end
-    expect(@config).to eq Webmachine.configuration
-  end
-
-  it "should return the module from the configure call so you can chain it" do
-    expect(Webmachine.configure {|c|}).to eq Webmachine
-  end
-end