net-http-server 0.2.2 → 0.2.4

data/net-http-server.gemspec

@@ -2,130 +2,61 @@
 
 require 'yaml'
 
-Gem::Specification.new do |gemspec|
-  root = File.dirname(__FILE__)
-  lib_dir = File.join(root,'lib')
-  files = if File.directory?('.git')
-            `git ls-files`.split($/)
-          elsif File.directory?('.hg')
-            `hg manifest`.split($/)
-          elsif File.directory?('.svn')
-            `svn ls -R`.split($/).select { |path| File.file?(path) }
-          else
-            Dir['{**/}{.*,*}'].select { |path| File.file?(path) }
-          end
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
 
-  filter_files = lambda { |paths|
-    case paths
-    when Array
-      (files & paths)
-    when String
-      (files & Dir[paths])
-    end
-  }
-
-  version = {
-    :file => 'net/http/server/version.rb',
-    :constant => 'Net::HTTP::Server::VERSION'
-  }
-
-  defaults = {
-    'name' => File.basename(File.dirname(__FILE__)),
-    'files' => files,
-    'executables' => filter_files['bin/*'].map { |path| File.basename(path) },
-    'test_files' => filter_files['{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'],
-    'extra_doc_files' => filter_files['*.{txt,rdoc,md,markdown,tt,textile}'],
-  }
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
 
-  metadata = defaults.merge(YAML.load_file('gemspec.yml'))
+                  require 'net/http/server/version'
+                  Net::HTTP::Server::VERSION
+                end
 
-  gemspec.name = metadata.fetch('name',defaults[:name])
-  gemspec.version = if metadata['version']
-                      metadata['version']
-                    else
-                      $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+  gem.metadata    = gemspec['metadata'] if gemspec['metadata']
 
-                      require version[:file]
-                      eval(version[:constant])
-                    end
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
 
-  gemspec.summary = metadata.fetch('summary',metadata['description'])
-  gemspec.description = metadata.fetch('description',metadata['summary'])
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
 
-  case metadata['license']
-  when Array
-    gemspec.licenses = metadata['license']
-  when String
-    gemspec.license = metadata['license']
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
   end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
 
-  case metadata['authors']
-  when Array
-    gemspec.authors = metadata['authors']
-  when String
-    gemspec.author = metadata['authors']
-  end
-
-  gemspec.email = metadata['email']
-  gemspec.homepage = metadata['homepage']
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || \
+                              '{test/{**/}*_test.rb,spec/{**/}*_spec.rb}']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
 
-  case metadata['require_paths']
-  when Array
-    gemspec.require_paths = metadata['require_paths']
-  when String
-    gemspec.require_path = metadata['require_paths']
-  end
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
 
-  gemspec.files = filter_files[metadata['files']]
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
 
-  gemspec.executables = metadata['executables']
-  gemspec.extensions = metadata['extensions']
-
-  if Gem::VERSION < '1.7.'
-    gemspec.default_executable = gemspec.executables.first
-  end
-
-  gemspec.test_files = filter_files[metadata['test_files']]
-
-  unless gemspec.files.include?('.document')
-    gemspec.extra_rdoc_files = metadata['extra_doc_files']
-  end
-
-  gemspec.post_install_message = metadata['post_install_message']
-  gemspec.requirements = metadata['requirements']
-
-  if gemspec.respond_to?(:required_ruby_version=)
-    gemspec.required_ruby_version = metadata['required_ruby_version']
-  end
-
-  if gemspec.respond_to?(:required_rubygems_version=)
-    gemspec.required_rubygems_version = metadata['required_ruby_version']
-  end
-
-  parse_versions = lambda { |versions|
-    case versions
-    when Array
-      versions.map { |v| v.to_s }
-    when String
-      versions.split(/,\s*/)
-    end
-  }
-
-  if metadata['dependencies']
-    metadata['dependencies'].each do |name,versions|
-      gemspec.add_dependency(name,parse_versions[versions])  
-    end
-  end
+  split = lambda { |string| string.split(/,\s*/) }
 
-  if metadata['runtime_dependencies']
-    metadata['runtime_dependencies'].each do |name,versions|
-      gemspec.add_runtime_dependency(name,parse_versions[versions])  
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
     end
   end
 
-  if metadata['development_dependencies']
-    metadata['development_dependencies'].each do |name,versions|
-      gemspec.add_development_dependency(name,parse_versions[versions])  
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
     end
   end
 end

data/spec/net/http/server/chunked_stream_spec.rb

@@ -11,39 +11,39 @@ describe Net::HTTP::Server::ChunkedStream do
       socket = StringIO.new("%x\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read.should == data
+      expect(stream.read).to eq(data)
     end
 
     it "should ignore any extension data, after the length field" do
       socket = StringIO.new("%x;lol\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read.should == data
+      expect(stream.read).to eq(data)
     end
 
     it "should read an amount of data from a socket, directly into a buffer" do
       length = 3
-      buffer = ''
+      buffer = String.new(encoding: Encoding::UTF_8)
 
       socket = StringIO.new("%x\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read(length,buffer).should == data[0,length]
+      expect(stream.read(length,buffer)).to eq(data[0,length])
     end
 
     it "should buffer unread data from the previously read chunk" do
       socket = StringIO.new("%x\r\n%s\r\n0\r\n\r\n" % [data.length, data])
       stream = described_class.new(socket)
 
-      stream.read(4).should == data[0,4]
-      stream.read.should == data[4..-1]
+      expect(stream.read(4)).to eq(data[0,4])
+      expect(stream.read).to eq(data[4..-1])
     end
 
     it "should return nil after it reads the last chunk" do
       socket = StringIO.new("0\r\n\r\n")
       stream = described_class.new(socket)
 
-      stream.read.should be_nil
+      expect(stream.read).to be_nil
     end
   end
 
@@ -52,7 +52,7 @@ describe Net::HTTP::Server::ChunkedStream do
       socket = StringIO.new
       stream = described_class.new(socket)
 
-      stream.write('foo').should == 3
+      expect(stream.write('foo')).to eq(3)
     end
 
     it "should write a length-line along with the data" do
@@ -61,7 +61,7 @@ describe Net::HTTP::Server::ChunkedStream do
 
       stream.write('foo')
 
-      socket.string.should == "3\r\nfoo\r\n"
+      expect(socket.string).to eq("3\r\nfoo\r\n")
     end
 
     it "should not write empty Strings" do
@@ -70,7 +70,7 @@ describe Net::HTTP::Server::ChunkedStream do
 
       stream.write('')
 
-      socket.string.should be_empty
+      expect(socket.string).to be_empty
     end
   end
 
@@ -81,7 +81,7 @@ describe Net::HTTP::Server::ChunkedStream do
 
       stream.close
 
-      socket.string.should == "0\r\n\r\n"
+      expect(socket.string).to eq("0\r\n\r\n")
     end
   end
 end

data/spec/net/http/server/daemon_spec.rb

@@ -8,17 +8,17 @@ describe Net::HTTP::Server::Daemon do
     subject { described_class.new { |request,response| } }
 
     it "should have a default host" do
-      subject.host.should_not be_nil
+      expect(subject.host).to eq(described_class::DEFAULT_HOST)
     end
 
     it "should have a default port" do
-      subject.port.should_not be_nil
+      expect(subject.port).to eq(described_class::DEFAULT_PORT)
     end
 
     it "should require a HTTP Request handler" do
-      lambda {
+      expect {
         described_class.new
-      }.should raise_error
+      }.to raise_error(ArgumentError,"no HTTP Request Handler block given")
     end
   end
 end

data/spec/net/http/server/parser_spec.rb

@@ -5,86 +5,86 @@ describe Net::HTTP::Server::Parser do
   it "should not parse garbage" do
     garbage = (1..255).map { |b| b.chr }.join * 100
 
-    lambda {
+    expect {
       subject.parse(garbage)
-    }.should raise_error(Parslet::ParseFailed)
+    }.to raise_error(Parslet::ParseFailed)
   end
 
   describe "request line" do
     it "should parse non-standard request methods" do
       request = subject.parse("FOO / HTTP/1.1\r\n\r\n")
 
-      request[:method].should == 'FOO'
+      expect(request[:method]).to eq('FOO')
     end
 
     it "should allow '*' as the path" do
       request = subject.parse("OPTIONS * HTTP/1.1\r\n\r\n")
 
-      request[:uri].should == '*'
+      expect(request[:uri]).to eq('*')
     end
 
     it "should not confuse the '/*' path with '*'" do
       request = subject.parse("OPTIONS /* HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/*'
+      expect(request[:uri][:path]).to eq('/*')
     end
 
     it "should parse absolute paths" do
       request = subject.parse("GET /absolute/path HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/absolute/path'
+      expect(request[:uri][:path]).to eq('/absolute/path')
     end
 
     it "should parse the params in the path" do
       request = subject.parse("GET /path;q=1;p=2 HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/path'
-      request[:uri][:params].should == 'q=1;p=2'
+      expect(request[:uri][:path]).to eq('/path')
+      expect(request[:uri][:params]).to eq('q=1;p=2')
     end
 
     it "should parse the query-string in the path" do
       request = subject.parse("GET /path?q=1&p=2 HTTP/1.1\r\n\r\n")
 
-      request[:uri][:path].should == '/path'
-      request[:uri][:query].should == 'q=1&p=2'
+      expect(request[:uri][:path]).to eq('/path')
+      expect(request[:uri][:query]).to eq('q=1&p=2')
     end
 
     it "should parse absolute URIs paths" do
       request = subject.parse("GET http://www.example.com:8080/path HTTP/1.1\r\n\r\n")
 
-      request[:uri][:scheme].should == 'http'
-      request[:uri][:host].should == 'www.example.com'
-      request[:uri][:port].should == '8080'
-      request[:uri][:path].should == '/path'
+      expect(request[:uri][:scheme]).to eq('http')
+      expect(request[:uri][:host]).to eq('www.example.com')
+      expect(request[:uri][:port]).to eq('8080')
+      expect(request[:uri][:path]).to eq('/path')
     end
 
     it "should parse non-http URIs" do
       request = subject.parse("GET xmpp://alice:secret@example.com/path HTTP/1.1\r\n\r\n")
 
-      request[:uri][:scheme].should == 'xmpp'
-      request[:uri][:user_info].should == 'alice:secret'
-      request[:uri][:host].should == 'example.com'
-      request[:uri][:path].should == '/path'
+      expect(request[:uri][:scheme]).to eq('xmpp')
+      expect(request[:uri][:user_info]).to eq('alice:secret')
+      expect(request[:uri][:host]).to eq('example.com')
+      expect(request[:uri][:path]).to eq('/path')
     end
 
     it "should parse the HTTP version" do
       request = subject.parse("GET /path HTTP/1.1\r\n\r\n")
 
-      request[:version].should == '1.1'
+      expect(request[:version]).to eq('1.1')
     end
 
     it "should allow future HTTP versions" do
       request = subject.parse("GET /path HTTP/2.0\r\n\r\n")
 
-      request[:version].should == '2.0'
+      expect(request[:version]).to eq('2.0')
     end
 
     it "should parse simple GET requests" do
       request = subject.parse("GET / HTTP/1.1\r\n\r\n")
 
-      request[:method].should == 'GET'
-      request[:uri][:path].should == '/'
-      request[:version].should == '1.1'
+      expect(request[:method]).to eq('GET')
+      expect(request[:uri][:path]).to eq('/')
+      expect(request[:version]).to eq('1.1')
     end
   end
 end

data/spec/net/http/server/requests_spec.rb

@@ -10,20 +10,20 @@ describe Net::HTTP::Server::Requests do
     it "should ignore requests that do not contain an HTTP version" do
       stream = StringIO.new("GET /\r\n")
 
-      read_request(stream).should be_nil
+      expect(read_request(stream)).to be_nil
     end
 
     it "should ignore requests with malformed headers" do
       stream = StringIO.new("GET / HTTP/1.1\r\nFoo: Bar\r\nBAZ\r\n\r\n")
 
-      read_request(stream).should be_nil
+      expect(read_request(stream)).to be_nil
     end
 
     it "should read requests with an HTTP Version and Headers" do
       request = "GET / HTTP/1.1\r\nFoo: Bar\r\n\r\n"
       stream = StringIO.new(request)
 
-      read_request(stream).should == request
+      expect(read_request(stream)).to eq(request)
     end
 
     it "should not read the body of the request" do
@@ -33,7 +33,7 @@ describe Net::HTTP::Server::Requests do
 
       read_request(stream)
 
-      stream.read.should == body
+      expect(stream.read).to eq(body)
     end
   end
 
@@ -42,21 +42,21 @@ describe Net::HTTP::Server::Requests do
       request = {:uri => {:scheme => 'https'}}
       normalize_uri(request)
 
-      request[:uri][:port].should == 443
+      expect(request[:uri][:port]).to eq(443)
     end
 
     it "should convert :port to an Integer" do
       request = {:uri => {:scheme => 'http', :port => '80'}}
       normalize_uri(request)
 
-      request[:uri][:port].should == 80
+      expect(request[:uri][:port]).to eq(80)
     end
 
     it "should replace a '*' URI with an empty Hash" do
       request = {:uri => '*'}
       normalize_uri(request)
 
-      request[:uri].should == {}
+      expect(request[:uri]).to eq({})
     end
   end
 
@@ -65,7 +65,7 @@ describe Net::HTTP::Server::Requests do
       request = {:headers => []}
       normalize_headers(request)
 
-      request[:headers].should == {}
+      expect(request[:headers]).to eq({})
     end
 
     it "should convert header names and values into a Hash" do
@@ -75,10 +75,10 @@ describe Net::HTTP::Server::Requests do
       ]}
       normalize_headers(request)
 
-      request[:headers].should == {
+      expect(request[:headers]).to eq({
         'Content-Type' => 'text/html',
         'Content-Length' => '5'
-      }
+      })
     end
 
     it "should group duplicate header names into the same Hash key" do
@@ -88,9 +88,9 @@ describe Net::HTTP::Server::Requests do
       ]}
       normalize_headers(request)
 
-      request[:headers].should == {
+      expect(request[:headers]).to eq({
         'Content-Type' => ['text/html', 'UTF8']
-      }
+      })
     end
   end
 end

data/spec/net/http/server/responses_spec.rb

@@ -17,23 +17,23 @@ describe Net::HTTP::Server::Responses do
     it "should write the HTTP Version" do
       parts = @stream.string.split(' ')
 
-      parts[0].should =~ /HTTP\/1.1/
+      expect(parts[0]).to match(/HTTP\/1.1/)
     end
 
     it "should write the Status Code" do
       parts = @stream.string.split(' ')
 
-      parts[1].should == status.to_s
+      expect(parts[1]).to eq(status.to_s)
     end
 
     it "should write the Reason String" do
       parts = @stream.string.split(' ')
 
-      parts[2].should == reason
+      expect(parts[2]).to eq(reason)
     end
 
     it "should end the line with a '\\r\\n'" do
-      @stream.string[-2..-1].should == "\r\n"
+      expect(@stream.string[-2..-1]).to eq("\r\n")
     end
   end
 
@@ -41,57 +41,57 @@ describe Net::HTTP::Server::Responses do
     it "should separate header names and values with a ': '" do
       write_headers(@stream, 'Foo' => 'Bar')
 
-      @stream.string.should include(': ')
+      expect(@stream.string).to include(': ')
     end
 
     it "should terminate each header with a '\\r\\n'" do
       write_headers(@stream, 'Foo' => 'Bar', 'Baz' => 'Qix')
 
-      @stream.string.split("\r\n").should =~ [
+      expect(@stream.string.split("\r\n")).to match_array([
         'Foo: Bar',
         'Baz: Qix'
-      ]
+      ])
     end
 
     it "should end the headers with a '\\r\\n'" do
       write_headers(@stream, {})
 
-      @stream.string.should == "\r\n"
+      expect(@stream.string).to eq("\r\n")
     end
 
     it "should write String headers" do
       write_headers(@stream, 'Content-Type' => 'text/html')
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Content-Type: text/html'
-      ]
+      ])
     end
 
     it "should write multiple headers for multi-line String values" do
       write_headers(@stream, 'Content-Type' => "text/html\ncharset=UTF8")
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Content-Type: text/html',
         'Content-Type: charset=UTF8'
-      ]
+      ])
     end
 
     it "should properly format Time values" do
       time = Time.parse('2011-01-25 14:15:29 -0800')
       write_headers(@stream, 'Date' => time)
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Date: Tue, 25 Jan 2011 22:15:29 GMT'
-      ]
+      ])
     end
 
     it "should write Array values as multiple headers" do
       write_headers(@stream, 'Content-Type' => ['text/html', 'charset=UTF8'])
 
-      @stream.string.split("\r\n").should == [
+      expect(@stream.string.split("\r\n")).to eq([
         'Content-Type: text/html',
         'Content-Type: charset=UTF8'
-      ]
+      ])
     end
   end
 
@@ -99,7 +99,7 @@ describe Net::HTTP::Server::Responses do
     it "should write each check of the body" do
       write_body(@stream,['one', 'two', 'three'])
 
-      @stream.string.should == 'onetwothree'
+      expect(@stream.string).to eq('onetwothree')
     end
   end
 end

data/spec/net/http/server/stream_spec.rb

@@ -9,17 +9,17 @@ describe Net::HTTP::Server::Stream do
 
     it "should read data from a socket" do
       stream = described_class.new(StringIO.new(data))
-      stream.read.should == data
+      expect(stream.read).to eq(data)
     end
 
     it "should read an amount of data from a socket, directly into a buffer" do
       length = 3
-      buffer = ''
+      buffer = String.new(encoding: Encoding::UTF_8)
 
       stream = described_class.new(StringIO.new(data))
       stream.read(length,buffer)
       
-      buffer.should == data[0,length]
+      expect(buffer).to eq(data[0,length])
     end
   end
 
@@ -30,7 +30,7 @@ describe Net::HTTP::Server::Stream do
       stream = described_class.new(StringIO.new())
       stream.each { |chunk| results << chunk }
 
-      results.should be_empty
+      expect(results).to be_empty
     end
 
     it "should yield each chunk in the stream" do
@@ -41,7 +41,7 @@ describe Net::HTTP::Server::Stream do
       stream = described_class.new(StringIO.new(data))
       stream.each { |chunk| results << chunk }
 
-      results.should == chunks
+      expect(results).to eq(chunks)
     end
   end
 
@@ -51,7 +51,7 @@ describe Net::HTTP::Server::Stream do
       data = chunks.join('')
 
       stream = described_class.new(StringIO.new(data))
-      stream.body.should == data
+      expect(stream.body).to eq(data)
     end
   end
 
@@ -60,7 +60,7 @@ describe Net::HTTP::Server::Stream do
       data = "foo\n\rbar"
 
       stream = described_class.new(StringIO.new)
-      stream.write(data).should == data.length
+      expect(stream.write(data)).to eq(data.length)
     end
   end
 end