hatetepe 0.5.0 → 0.5.1

data/hatetepe.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   
   s.add_development_dependency "rspec"
   s.add_development_dependency "yard"
-  s.add_development_dependency "rdiscount"
+  s.add_development_dependency "kramdown"
 
   s.files         = `git ls-files`.split("\n") - [".gitignore", ".rspec", ".travis.yml", ".yardopts"]
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/hatetepe/cli.rb

@@ -27,36 +27,35 @@ module Hatetepe
     def start
       require "hatetepe/server"
       require "rack"
-      
-      ENV["RACK_ENV"] = options[:env] || ENV["RACK_ENV"] || "development"
-      $stderr << "We're in #{ENV["RACK_ENV"]}\n"
-      $stderr.flush
-      
-      rackup = File.expand_path(options[:rackup] || "config.ru")
-      $stderr << "Booting from #{rackup}\n"
-      $stderr.flush
-      
-      app = Rack::Builder.parse_file(rackup)[0]
+
+      config          = config_for(options)
+      ENV["RACK_ENV"] = config[:env]
+
+      $stderr << "We're in #{config[:env]}\n"
+      $stderr << "Booting from #{config[:rackup]}\n"
 
       EM.epoll
       EM.synchrony do
+        $stderr << "Binding to #{config[:host]}:#{config[:port]}\n"
+
         trap("INT") { EM.stop }
         trap("TERM") { EM.stop }
-        
-        host    = options[:bind]    || "127.0.0.1"
-        port    = options[:port]    || 3000
-        timeout = options[:timeout] || Hatetepe::Server::CONFIG_DEFAULTS[:timeout]
-        
-        $stderr << "Binding to #{host}:#{port}\n"
-        $stderr.flush
-
-        Server.start({
-          app:     app,
-          host:    host,
-          port:    port,
-          timeout: timeout
-        })
+        Server.start(config)
       end
     end
+
+    private
+
+    def config_for(options)
+      rackup = File.expand_path(options[:rackup] || "config.ru")
+      {
+        env:     options[:env]  || ENV["RACK_ENV"] || "development",
+        host:    options[:bind] || "127.0.0.1",
+        port:    options[:port] || 3000,
+        timeout: options[:timeout],
+        app:     Rack::Builder.parse_file(rackup)[0],
+        rackup:  rackup
+      }
+    end
   end
 end

data/lib/hatetepe/connection.rb

@@ -2,7 +2,7 @@ module Hatetepe
   module Connection
     attr_accessor :processing_enabled
     alias_method :processing_enabled?, :processing_enabled
-    
+
     def remote_address
       sockaddr && sockaddr[1]
     end
@@ -57,5 +57,17 @@ module Hatetepe
         end
       end
     end
+
+    def comm_inactivity_timeout=(seconds)
+      unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+        super
+      end
+    end
+
+    def pending_connect_timeout=(seconds)
+      unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+        super
+      end
+    end
   end
 end

data/lib/hatetepe/parser.rb

@@ -19,47 +19,32 @@ module Hatetepe
     attr_reader :message
     
     def initialize(&block)
+      initialize_parser
+      reset
+
+      if block
+        block.arity == 0 ? instance_eval(&block) : block.call(self)
+      end
+    end
+
+    def initialize_parser
       @parser = HTTP::Parser.new.tap do |p|
-        p.on_headers_complete = proc do
-          version = p.http_version.join(".")
-          if p.http_method
-            @message = Request.new(p.http_method, p.request_url,
-                                   p.headers, Body.new, version)
-            event! :request, message
-          else
-            @message = Response.new(p.status_code, p.headers, Body.new, version)
-            event! :response, message
-          end
-          
-          event! :headers, message.headers
-          event! :body, message.body
+        p.on_headers_complete = proc do |headers|
+          headers_complete(p) if @headers_counter.even?
+          @headers_counter += 1
           nil
         end
         
-        p.on_body = proc do |chunk|
-          message.body.write chunk unless message.body.closed_write?
-        end
-        
+        p.on_body             = method(:body)
         p.on_message_complete = method(:complete)
       end
-      
-      reset
-      
-      if block
-        block.arity == 0 ? instance_eval(&block) : block.call(self)
-      end
     end
     
     def reset
       @parser.reset!
       event! :reset
       @message = nil
-    end
-    
-    def complete
-      message.body.rewind!
-      message.body.close_write unless message.body.closed_write?
-      event! :complete
+      @headers_counter = 0
     end
     
     def <<(data)
@@ -67,5 +52,32 @@ module Hatetepe
     rescue HTTP::Parser::Error => e
       raise Hatetepe::ParserError, e.message, e.backtrace
     end
+
+    private
+
+    def headers_complete(parser)
+      args = [ parser.headers, Body.new, parser.http_version.join(".") ]
+      if parser.http_method
+        @message = Request.new(parser.http_method, parser.request_url, *args)
+        event! :request, @message
+      else
+        @message = Response.new(parser.status_code, *args)
+        event! :response, @message
+      end
+
+      event! :headers, message.headers
+      event! :body, message.body
+    end
+
+    def body(chunk)
+      message.body.write chunk unless message.body.closed_write?
+    end
+
+    def complete
+      message.body.rewind!
+      message.body.close_write unless message.body.closed_write?
+      event! :complete
+      @headers_counter += 1 if @headers_counter.odd?
+    end
   end
 end

data/lib/hatetepe/server.rb

@@ -36,15 +36,7 @@ module Hatetepe::Server
     @builder.on_write  &method(:send_data)
     # @builder.on_write {|data| p "<--| #{data}" }
 
-    app =
-      if config[:app].respond_to?(:call)
-        [ *CONFIG_DEFAULTS[:app], config[:app] ]
-      else
-        config[:app].dup
-      end
-    @app = app.inject(app.pop) do |inner, outer|
-      outer.new(inner, self)
-    end
+    @app = build_app(config[:app])
 
     self.comm_inactivity_timeout = config[:timeout]
   end
@@ -93,4 +85,18 @@ module Hatetepe::Server
   def stop!
     close_connection_after_writing
   end
+
+  private
+
+  def build_app(app)
+    app =
+      if app.respond_to?(:call)
+        [ *CONFIG_DEFAULTS[:app], app ]
+      else
+        app.dup
+      end
+    app.inject(app.pop) do |inner, outer|
+      outer.new(inner, self)
+    end
+  end
 end

data/lib/hatetepe/version.rb

@@ -1,3 +1,3 @@
 module Hatetepe
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/spec/integration/cli/start_spec.rb

@@ -35,7 +35,7 @@ describe Hatetepe::CLI do
       Hatetepe::Server.should_receive(:start) do |config|
         config[:host].should    == "127.0.0.1"
         config[:port].should    equal(3000)
-        config[:timeout].should == 5
+        config[:timeout].should be_nil
         
         config[:app].should    equal(rackup[0])
         ENV["RACK_ENV"].should == "development"

data/spec/integration/client/timeout_spec.rb

@@ -16,6 +16,10 @@ describe Hatetepe::Client do
   end
 
   before do
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+      pending "EventMachine timeouts are not available on JRuby"
+    end
+
     Hatetepe::Server.start(options.merge(timeout: 0))
   end
 

data/spec/integration/server/timeout_spec.rb

@@ -3,6 +3,12 @@ require "hatetepe/client"
 require "hatetepe/server"
 
 describe Hatetepe::Server do
+  before do
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+      pending "EventMachine timeouts are not available on JRuby"
+    end
+  end
+
   let :options do
     { host: "127.0.0.1", port: 3123 }
   end

data/spec/unit/connection_spec.rb

@@ -6,10 +6,10 @@ describe Hatetepe::Connection do
     Object.new.extend Hatetepe::Connection
   end
   
-  let(:peername) { "\x02\x00\x86\xF6\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00" }
   let(:address) { "127.0.0.1" }
-  let(:port) { 34550 }
-  
+  let(:port) { 34450 }
+  let(:peername) { Socket.pack_sockaddr_in(port, address) }
+
   before { conn.stub :get_peername => peername }
   
   describe "#remote_address" do

data/spec/unit/parser_spec.rb

@@ -164,20 +164,11 @@ describe Hatetepe::Parser do
   context "#on_body {|body| ... }" do
     it "evals the block when the body starts" do
       block.should_receive(:call) {|body|
-        body.should equal(parser.message.body)
-        
-        # we'd have to #close_write to get body#length
-        body.io.length.should == 0
+        Fiber.new { body.read.should eq("Hello!") }.resume
       }
       
       parser.on_body &block
       do_request
-      
-      parser.message.body.tap {|b|
-        b.rewind
-        b.length.should == 6
-        b.read.should == "Hello!"
-      }
     end
     
     it "changes the state to :body" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hatetepe
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-17 00:00:00.000000000 Z
+date: 2012-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
@@ -124,7 +124,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdiscount
+  name: kramdown
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements: