webmachine 1.2.2 → 1.6.0

data/lib/webmachine/adapters/hatetepe.rb

@@ -1,108 +0,0 @@
-require 'hatetepe/server'
-
-unless Hatetepe::VERSION >= '0.5.0'
-  raise LoadError, 'webmachine only supports hatetepe >= 0.5.0'
-end
-
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-require 'webmachine/chunked_body'
-
-module Webmachine
-  module Adapters
-    class Hatetepe < Adapter
-      def options
-        {
-          :host => configuration.ip,
-          :port => configuration.port,
-          :app  => [
-            ::Hatetepe::Server::Pipeline,
-            ::Hatetepe::Server::KeepAlive,
-            method(:call)
-          ]
-        }
-      end
-
-      def run
-        EM.epoll
-        EM.synchrony do
-          ::Hatetepe::Server.start(options)
-          trap("INT") { shutdown }
-        end
-      end
-
-      def shutdown
-        EM.stop
-      end
-
-      def call(request, &respond)
-        response = Webmachine::Response.new
-        dispatcher.dispatch(convert_request(request), response)
-
-        respond.call(convert_response(response))
-      end
-
-      private
-
-      def convert_request(request)
-        args = [
-          request.verb,
-          build_request_uri(request),
-          Webmachine::Headers[request.headers.dup],
-          Body.new(request.body)
-        ]
-        Webmachine::Request.new(*args)
-      end
-
-      def convert_response(response)
-        response.headers["Server"] = [
-          Webmachine::SERVER_STRING,
-          "hatetepe/#{::Hatetepe::VERSION}"
-        ].join(" ")
-
-        args = [
-          response.code.to_i,
-          response.headers,
-          convert_body(response.body)
-        ]
-        ::Hatetepe::Response.new(*args)
-      end
-
-      def convert_body(body)
-        if body.respond_to?(:call)
-          [ body.call ]
-        elsif body.respond_to?(:to_s)
-          [ body.to_s ]
-        else
-          body
-        end
-      end
-
-      def build_request_uri(request)
-        uri = URI.parse(request.uri)
-        uri.scheme = "http"
-
-        host     = request.headers.fetch("Host", "").split(":")
-        uri.host = host[0]      || configuration.ip
-        uri.port = host[1].to_i || configuration.port
-
-        URI.parse(uri.to_s)
-      end
-
-      class Body < Struct.new(:body)
-        def each(&block)
-          body.rewind
-          body.each(&block)
-        end
-
-        def to_s
-          body.rewind
-          body.read.to_s
-        end
-      end
-    end
-  end
-end

data/lib/webmachine/adapters/mongrel.rb

@@ -1,127 +0,0 @@
-require 'mongrel'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-require 'webmachine/chunked_body'
-
-module Webmachine
-  module Adapters
-    # Connects Webmachine to Mongrel.
-    class Mongrel < Adapter
-
-      # Starts the Mongrel adapter
-      def run
-        defaults = {
-          :port => configuration.port,
-          :host => configuration.ip,
-          :dispatcher => dispatcher
-        }.merge(configuration.adapter_options)
-        @config = ::Mongrel::Configurator.new(defaults) do
-          listener do
-            uri '/', :handler => Webmachine::Adapters::Mongrel::Handler.new(defaults[:dispatcher])
-          end
-          trap("INT") { stop }
-          run
-        end
-        @config.join
-      end
-
-      def shutdown
-        # The second argument tells mongrel to block until all listeners are shut down.
-        # This causes the mongrel tests to be very slow, but faster methods cause errors.
-        @config.stop(false, true) if @config
-      end
-
-      # A Mongrel handler for Webmachine
-      class Handler < ::Mongrel::HttpHandler
-        def initialize(dispatcher)
-          @dispatcher = dispatcher
-          super()
-        end
-
-        # Processes an individual request from Mongrel through Webmachine.
-        def process(wreq, wres)
-          header = Webmachine::Headers.from_cgi(wreq.params)
-
-          request = Webmachine::Request.new(wreq.params["REQUEST_METHOD"],
-                                            URI.parse(wreq.params["REQUEST_URI"]),
-                                            header,
-                                            RequestBody.new(wreq))
-
-          response = Webmachine::Response.new
-          @dispatcher.dispatch(request, response)
-
-          begin
-            wres.status = response.code.to_i
-            wres.send_status(nil)
-
-            response.headers.each do |k, vs|
-              [*vs].each do |v|
-                wres.header[k] = v
-              end
-            end
-
-            wres.header['Server'] = [Webmachine::SERVER_STRING, "Mongrel/#{::Mongrel::Const::MONGREL_VERSION}"].join(" ")
-            wres.send_header
-
-            case response.body
-            when String
-              wres.write response.body
-              wres.socket.flush
-            when Enumerable
-              # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
-              if response.headers["Transfer-Encoding"] == "chunked"
-                Webmachine::ChunkedBody.new(response.body).each do |part|
-                  wres.write part
-                  wres.socket.flush
-                end
-              else
-                response.body.each do |part|
-                  wres.write part
-                  wres.socket.flush
-                end
-              end
-            else
-              if response.body.respond_to?(:call)
-                Webmachine::ChunkedBody.new(Array(response.body.call)).each do |part|
-                  wres.write part
-                  wres.socket.flush
-                end
-              end
-            end
-          ensure
-            response.body.close if response.body.respond_to? :close
-          end
-        end
-      end # class Handler
-
-      # Wraps a Mongrel request body so that it can behave like a
-      # String.
-      # @api private
-      class RequestBody
-        # @return the request from Mongrel
-        attr_reader :request
-
-        # @param request the request from Mongrel
-        def initialize(request)
-          @request = request
-        end
-
-        # @return [String] the request body as a string
-        def to_s
-          request.body.rewind
-          request.body.read
-        end
-
-        # @yield [chunk]
-        # @yieldparam [String] chunk a chunk of the request body
-        def each(&block)
-          request.body.each(&block)
-        end
-      end # class RequestBody
-
-    end # module Mongrel
-  end # module Adapters
-end # module Webmachine

data/lib/webmachine/dispatcher/not_found_resource.rb

@@ -1,5 +0,0 @@
-class Webmachine::Dispatcher::NotFoundResource < Webmachine::Resource
-  def resource_exists?
-    false
-  end
-end

data/lib/webmachine/fiber18.rb

@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-# Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
-# (c) 2008 Aman Gupta (tmm1)
-
-unless defined? Fiber
-  require 'thread'
-
-  # Raised by {Fiber} when they are used improperly
-  class FiberError < StandardError; end
-
-  # Implements a reasonably-compatible Fiber class that can be used on
-  # Rubies that have 1.8-style APIs.
-  class Fiber
-    # @yield the block that should be executed inside the Fiber
-    def initialize
-      raise ArgumentError, 'new Fiber requires a block' unless block_given?
-
-      @yield = Queue.new
-      @resume = Queue.new
-
-      @thread = Thread.new{ @yield.push [ *yield(*@resume.pop) ] }
-      @thread.abort_on_exception = true
-      @thread[:fiber] = self
-    end
-    attr_reader :thread
-
-    # Returns true if the fiber can still be resumed (or transferred
-    # to). After finishing execution of the fiber block this method
-    # will always return false.
-    def alive?
-      @thread.alive?
-    end
-
-    # Resumes the fiber from the point at which the last Fiber.yield
-    # was called, or starts running it if it is the first call to
-    # resume. Arguments passed to resume will be the value of the
-    # Fiber.yield expression or will be passed as block parameters to
-    # the fiber’s block if this is the first resume.
-    #
-    # Alternatively, when resume is called it evaluates to the arguments
-    # passed to the next Fiber.yield statement inside the fiber’s block or
-    # to the block value if it runs to completion without any Fiber.yield
-    def resume *args
-      raise FiberError, 'dead fiber called' unless @thread.alive?
-      @resume.push(args)
-      result = @yield.pop
-      result.size > 1 ? result : result.first
-    end
-
-    # Yields control back to the context that resumed this fiber,
-    # passing along any arguments that were passed to it. The fiber
-    # will resume processing at this point when resume is called
-    # next. Any arguments passed to the next resume will be the value
-    # that this Fiber.yield expression evaluates to.
-    # @note This method is only called internally. In your code, use
-    #   {Fiber.yield}.
-    def yield *args
-      @yield.push(args)
-      result = @resume.pop
-      result.size > 1 ? result : result.first
-    end
-
-    # Yields control back to the context that resumed the fiber,
-    # passing along any arguments that were passed to it. The fiber
-    # will resume processing at this point when resume is called
-    # next. Any arguments passed to the next resume will be the value
-    # that this Fiber.yield expression evaluates to.  This will raise
-    # a {FiberError} if you are not inside a {Fiber}.
-    # @raise FiberError
-    def self.yield *args
-      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
-      fiber.yield(*args)
-    end
-
-    # Returns the current fiber.  If you are not running in the
-    # context of a fiber this method will raise a {FiberError}.
-    # @raise FiberError
-    def self.current
-      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
-    end
-
-    # Returns a string containing a human-readable representation of
-    # this Fiber.
-    def inspect
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
-    end
-  end
-end

data/spec/webmachine/adapters/hatetepe_spec.rb

@@ -1,60 +0,0 @@
-require "spec_helper"
-
-examples = proc do
-  let(:configuration) { Webmachine::Configuration.default              }
-  let(:dispatcher)    { Webmachine::Dispatcher.new                     }
-  let(:adapter)       { described_class.new(configuration, dispatcher) }
-
-  it "inherits from Webmachine::Adapter" do
-    adapter.should be_a(Webmachine::Adapter)
-  end
-
-  describe "#run" do
-    it "starts a server" do
-      Hatetepe::Server.should_receive(:start).with(adapter.options) { adapter.shutdown }
-      adapter.run
-    end
-  end
-
-  describe "#call" do
-    let :request do
-      Hatetepe::Request.new(:get, "/", {}, StringIO.new("hello, world!"))
-    end
-
-    it "builds a string-like and enumerable request body" do
-      dispatcher.should_receive(:dispatch) do |req, res|
-        req.body.to_s.should       eq("hello, world!")
-        enum_to_s(req.body).should eq("hello, world!")
-      end
-      adapter.call(request) {}
-    end
-
-    shared_examples "enumerable response body" do
-      before do
-        dispatcher.stub(:dispatch) {|_, response| response.body = body }
-      end
-
-      it "builds an enumerable response body" do
-        adapter.call(request) do |response|
-          enum_to_s(response.body).should eq("bye, world!")
-        end
-      end
-    end
-
-    describe "with normal response" do
-      let(:body) { "bye, world!" }
-
-      it_behaves_like "enumerable response body"
-    end
-
-    describe "with streaming response" do
-      let(:body) { proc { "bye, world!" } }
-
-      it_behaves_like "enumerable response body"
-    end
-  end
-
-  def enum_to_s(enum)
-    enum.to_enum.to_a.join
-  end
-end

data/spec/webmachine/adapters/mongrel_spec.rb

@@ -1,16 +0,0 @@
-require "spec_helper"
-require "webmachine/spec/adapter_lint"
-
-begin
-  describe Webmachine::Adapters::Mongrel do
-    it_should_behave_like :adapter_lint do
-      it "should set Server header" do
-        response = client.request(Net::HTTP::Get.new("/test"))
-        response["Server"].should match(/Webmachine/)
-        response["Server"].should match(/Mongrel/)
-      end
-    end
-  end
-rescue LoadError
-  warn "Platform is #{RUBY_PLATFORM}: skipping mongrel adapter spec."
-end