kamu-wang 0.02

data/lib/wang.rb

@@ -0,0 +1,437 @@
+# vim: set noet:
+#
+# WANG - Web Access with No Grief
+#   http://github.com/kamu/wang/
+
+require 'socket'
+require 'uri'
+require 'stringio'
+require 'zlib'
+require 'logger'
+require 'yaml'
+require 'timeout'
+require 'base64'
+
+class URI::Generic
+	def to_uri
+		self
+	end
+end
+
+class String
+	def to_uri
+		URI.parse(self)
+	end
+end
+
+module WANG
+	Response = Struct.new(:method, :uri, :status, :headers)
+
+	DEFAULT_OPEN_TIMEOUT = 60
+	DEFAULT_READ_TIMEOUT = 60
+	INFINITE_REDIR_COUNT = 7
+
+	# Creates a new instance of WANG::Client
+	#
+	# For more info, check WANG::Client.new 
+	def self.new *args
+		Client.new(*args)
+	end
+
+	class TCPSocket < TCPSocket # add the timeouts :nodoc:
+		def initialize *args # allows passing of the timeout values
+			custom_args = args.shift
+			@read_timeout = custom_args[:read_timeout]
+			open_timeout = custom_args[:open_timeout]
+			Timeout::timeout(open_timeout) { super }
+		end
+
+		TIMEOUT_READ = %w{read readpartial gets readline}
+		TIMEOUT_READ.each {|m|
+			class_eval "def #{m}(*args); Timeout::timeout(@read_timeout) { super }; end;"
+		}
+	end
+
+	class Client
+		attr_accessor :responses
+
+		# Creates a new instance of WANG::Client
+		# 
+		# Accepts a hash containing named arguments. Arguments:
+		# [:read_timeout] defines the timeout for socket reading in seconds
+		# [:open_timeout] defines the timeout for connecting in seconds
+		# [:debug] any value passed defines debug mode
+		# [:proxy_address] defines the proxy address to use for all the requests made (host:port)
+		def initialize args = {}
+			@log = Logger.new(STDOUT)
+			@log.level = args[:debug] ? Logger::DEBUG : Logger::WARN
+
+			@jar = Jar.new
+			@socket = nil
+			@host, @port = nil, nil # create a struct that combines host & port?
+			@responses = []
+			@read_timeout = args[:read_timeout] || DEFAULT_READ_TIMEOUT
+			@open_timeout = args[:open_timeout] || DEFAULT_OPEN_TIMEOUT
+			@proxy_host, @proxy_port = args[:proxy_address] ? args[:proxy_address].split(':', 2) : [nil, nil]
+
+			@log.debug("Connecting through a proxy: #{@proxy_host}:#{@proxy_port}") if @proxy_host
+			@log.debug("Using #{@read_timeout} as the read timeout and #{@open_timeout} as the open timeout")
+		end
+
+		# Issues a HEAD request.
+		#
+		# Returns +nil+ for the body.
+		def head url, referer = nil
+			@log.debug("HEAD: #{url.to_s}")
+			request('HEAD', url.to_uri, referer)
+		end
+
+		# Fetches a page using GET method
+		#
+		# If passed, referer will be sent to the server. Otherwise the last visited URL will be sent to the server as the referer.
+		def get url, referer = nil
+			@log.debug("GET: #{url.to_s}")
+			request("GET", url.to_uri, referer)
+		end
+
+		# Fetches a page using POST method
+		#
+		# Data can either be a String or a Hash. If passed a String, it will send it to the server as the POST data. If passed a Hash, it will be converted to post data and correctly escaped.
+		#
+		# If passed, referer will be sent to the server. Otherwise the last visited URL will be sent to the server as the referer.
+		def post url, data, referer = nil
+			@log.debug("POST: #{url.to_s}")
+			request("POST", url.to_uri, referer, data)
+		end
+
+		# Issues a PUT request. See post for more details.
+		def put url, data, referer = nil
+			@log.debug("PUT: #{url.to_s}")
+			request("PUT", url.to_uri, referer, data)
+		end
+
+		# Issues a DELETE request.
+		#
+		# Returns +nil+ for the body.
+		def delete url, referer = nil
+			@log.debug("DELETE: #{url.to_s}")
+			request("DELETE", url.to_uri, referer)
+		end
+
+		# Saves cookie from this Client instance's Jar to the given io
+		def save_cookies io
+			@jar.save(io)
+		end
+
+		# Loads cookies to this Client instance's Jar from the given io
+		def load_cookies io
+			@jar.load(io)
+		end
+
+		# Sets the HTTP authentication username & password, which are then used for requests
+		# Call with +nil+ as username to remove authentication
+		def set_auth username, password=''
+			@http_auth = username ? Base64.encode64(username+':'+password).chomp : nil # for some reason, encode64 might add a \n
+		end
+
+		private
+		def request method, uri, referer = nil, data = nil
+			uri.path = "/" if uri.path.empty? # fix the path to contain / right here, otherwise it should be added to cookie stuff too
+			uri = @responses.last.uri + uri unless uri.is_a?(URI::HTTP) # if the uri is relative, combine it with the uri of the latest response
+			check_socket *(@proxy_host ? [@proxy_host, @proxy_port] : [uri.host, uri.port])
+
+			referer = referer || @responses.last.nil? ? nil : @responses.last.uri
+			@responses.clear if not @responses.empty? and not redirect?(@responses.last.status)
+
+			#http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3
+			#there's no defined redir count that's considered infinite, so try something that makes sense
+			if @responses.length > INFINITE_REDIR_COUNT
+				return #raise an error?
+			end
+
+			@socket << generate_request_headers(method, uri, referer)
+			@socket << "Authorization: Basic #{@http_auth}\r\n" if @http_auth
+
+			if @jar.has_cookies_for?(uri)
+				@socket << "Cookie: #{@jar.cookies_for(uri)}\r\n"
+				@log.debug("SENDING COOKIES: #{@jar.cookies_for(uri)}")
+			end
+
+			data = data.map {|k,v| "#{Utils.escape(k)}=#{Utils.escape(v)}"}.join("&") if data.is_a?(Hash)
+
+			if data
+				@socket << "Content-Type: application/x-www-form-urlencoded\r\n"
+				@socket << "Content-Length: #{data.length}\r\n"
+			end
+			@socket << "\r\n"
+			@socket << data if data
+
+			status = read_status
+			@log.debug("STATUS: #{status}")
+			headers = read_headers(uri)
+			@log.debug("HEADERS: #{headers.inspect}")
+			body = read_body(headers) if returns_body?(method)
+			@log.debug("WANGJAR: #{@jar.inspect}")
+
+			@socket.close if headers["connection"] =~ /close/
+
+			@responses << Response.new(method, uri, status, headers)
+			return follow_redirect(headers["location"]) if redirect?(status)
+
+			body &&= decompress(headers["content-encoding"], body)
+
+			return status, headers, body
+		end
+
+		def generate_request_headers request_method, uri, referer
+			request_path = uri.path + (uri.query.nil? ? '' : "?#{uri.query}")
+			request_host = uri.host + (uri.port ? ":#{uri.port}" : '')
+			[
+				"#{request_method} #{@proxy_host ? uri.to_s : request_path} HTTP/1.1",
+				"Host: #{request_host}",
+				"User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.12) Gecko/20080201 Firefox/2.0.0.12",
+				"Accept: application/x-shockwave-flash,text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",
+				"Accept-Language: en-us,en;q=0.5",
+				"Accept-Encoding: gzip,deflate,identity",
+				"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+				"Keep-Alive: 300",
+				"Connection: keep-alive",
+				referer.nil? ? "" : "Referer: #{referer}\r\n" # an extra \r\n is needed for the last entry
+			].join("\r\n")
+		end
+
+		def read_status
+			line = @socket.gets("\n")
+			status = line.match(%r{^HTTP/1\.\d (\d+) })[1]
+			return status.to_i
+		end
+
+		def read_headers uri
+			headers = Hash.new
+			key = nil # allow using the latest key when appending multiline headers
+			while header = @socket.gets("\n")
+				header.chomp!
+				break if header.empty?
+				if header =~ /^\s/
+					headers[key] << header.strip
+				else
+					key, val = header.split(": ", 2)
+					if key =~ /^Set-Cookie2?$/i #do we dare consider set-cookie2 the same?
+						@jar.consume(val, uri)
+					else
+						headers.store(key.downcase, val)
+					end
+				end
+			end
+
+			return headers
+		end
+
+		def read_body headers
+			body = ""
+			if headers["transfer-encoding"] =~ /chunked/i # read chunked body
+				while true
+					line = @socket.readline
+					chunk_len = line.slice(/[0-9a-fA-F]+/).hex
+					break if chunk_len == 0
+					while chunk_len > 0 # make sure to read the whole chunk
+						buf = @socket.read(chunk_len)
+						chunk_len -= buf.length
+						body << buf
+					end
+					@socket.read 2 # read the damn linechange
+				end
+				until (line = @socket.gets) and (line.nil? or line.sub(/\r?\n?/, "").empty?); end # read the chunk footers and the last line
+			elsif headers["content-length"]
+				clen = headers["content-length"].to_i
+				while body.length < clen
+					body << @socket.read([clen - body.length, 4096].min)
+				end
+			else #fallback that'll just consume all the data available 
+				begin
+					while true
+						body << @socket.readpartial(4096)
+					end
+				rescue EOFError
+				end
+			end
+
+			return body
+		end
+
+		# Given an HTTP status code, returns whether it signifies a redirect.
+		def redirect? status
+			status.to_i / 100 == 3
+		end
+
+		# Given an HTTP method, returns whether a body should be read.
+		def returns_body? request_method
+			not ['HEAD', 'DELETE'].include?(request_method)
+		end
+
+		def follow_redirect location
+			@log.debug(location.inspect)
+			dest = location.to_uri
+			get(dest)
+		end
+
+		def decompress type, body
+			case type
+			when "gzip"
+				return Zlib::GzipReader.new(StringIO.new(body)).read
+			when "deflate"
+				begin
+					return Zlib::Inflate.inflate(body)
+				rescue Zlib::DataError # check http://www.ruby-forum.com/topic/136825 for more info
+					return Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(body)
+				end
+			else
+				return body
+			end
+		end
+
+		def check_socket host, port = 'http'
+			connect(host, port) if @socket.nil? or @socket.closed? or @host.nil? or not @host.eql? host or @port.nil? or not @port.eql? port
+		end
+
+		def connect host, port
+			@log.debug("Connecting to #{host}:#{port}")
+			@socket.close unless @socket.nil? or @socket.closed?
+			@socket = TCPSocket.new({:read_timeout => @read_timeout, :open_timeout => @open_timeout}, host, port)
+			@host = host
+			@port = port
+		end
+	end
+
+	class Cookie
+		attr_accessor :key, :value, :domain, :path, :expires
+
+		def initialize key = nil, value = nil
+			@key, @value = key, value
+			@domain, @path, @expires = nil
+		end
+
+		def parse raw_cookie, uri = nil
+			keyval, *attributes = raw_cookie.split(/;\s*/)
+			@key, @value = keyval.split("=", 2)
+
+			attributes.each do |at|
+				case at
+				when /domain=(.*)/i
+					@domain = $1
+				when /expires=(.*)/i
+					@expires = begin
+					   Time.parse($1)
+				   	rescue
+					   nil
+					end
+				when /path=(.*)/i
+					@path = $1
+				end
+			end
+
+			@domain = uri.host if @domain.nil? and uri
+			@path = "/" if @path.nil? and uri
+			@path.sub!(/\/$/, "") if @path #remove the trailing /, because path matching automatically adds it
+
+			self
+		end
+
+		def same? c
+			self.key.eql? c.key and self.domain.eql? c.domain and self.path.eql? c.path
+		end
+
+		def match? uri
+			match_domain?(uri.host) and match_path?(uri.path)
+		end
+
+		def expired?
+			@expires.is_a?(Time) ? @expires < Time.now : false
+		end
+
+		def match_domain? domain # TODO check if this fully follows the spec
+			case @domain
+			when /^\d+\.\d+\.\d+\.\d+$/ # ip address
+				domain.eql?(@domain)
+			when /^\./ # so domain = site.com and subdomains could match @domain to .site.com
+				domain =~ /#{Regexp.escape(@domain)}$/i
+			else
+				domain.downcase.eql?(@domain.downcase)
+			end
+		end
+
+		def match_path? path
+			path =~ /^#{Regexp.escape(@path)}(?:\/.*)?$/
+		end
+	end
+
+	class Jar
+		def initialize
+			@jar = []
+		end
+
+		def consume raw_cookie, uri = nil
+			cookie = Cookie.new.parse(raw_cookie, uri)
+			add(cookie)
+		end
+
+		def add c
+			i = index(c)
+			if i.nil?
+				@jar << c
+			else
+				@jar[i] = c
+			end
+		end
+
+		def has_cookies_for? uri
+			not cookies_for(uri).empty?
+		end
+
+		def cookies_for uri
+			@jar -= @jar.select { |c| c.expired? }
+			@jar.select { |c| c.match?(uri) }.map{ |c| "#{c.key}=#{c.value}" }.join("; ")
+		end
+
+		def index c
+			@jar.each do |cookie|
+				return @jar.index(cookie) if cookie.same? c
+			end
+
+			nil
+		end
+
+		def include? c
+			not index(c).nil?
+		end
+
+		def save io
+			io << @jar.to_yaml
+			io.close
+		end
+
+		def load io
+			saved_jar = YAML::load(io)
+
+			saved_jar.each do |c|
+				add(c)
+			end
+		end
+	end
+
+	module Utils
+		# URL-encode a string.
+		def self.escape string
+			string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+				'%' + $1.unpack('H2' * $1.size).join('%').upcase
+			end.tr(' ', '+')
+		end
+			
+		# URL-decode a string.
+		def self.unescape string
+			string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+				[$1.delete('%')].pack('H*')
+			end
+		end
+	end
+end

data/rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rcov/rcovtask'
+
+task :default => [:test]
+
+spec = Gem::Specification.new do |s|
+	s.platform = Gem::Platform::RUBY
+	s.name = 'wang'
+	s.version = "0.01"
+	s.summary = "Web Access with No Grief."
+	s.authors = ["Kamu", "Joux3"]
+	s.email = "mr.kamu@gmail.com"
+	s.homepage = "http://github.com/kamu/wang/tree"
+	s.requirements << 'none'
+	s.require_path = 'lib'
+	s.files = FileList["rakefile", "lib/**/*", "test/**/*"]
+	s.test_files = FileList["test/wang_test.rb"]
+end
+
+Rake::TestTask.new do |t|
+	t.test_files = FileList["test/wang_test.rb"]
+	t.verbose = true
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+end
+
+Rcov::RcovTask.new do |t|
+	t.test_files = FileList["test/wang_test.rb"]
+	t.verbose = true
+end

data/test/htdigest

@@ -0,0 +1 @@
+tester:WANG digest HTTP auth test:45485e998d046e343f2b4550520a1ae6

data/test/wang_test.rb

@@ -0,0 +1,178 @@
+# vim: set noet:
+#
+# WANG - Web Access with No Grief
+#   http://github.com/kamu/wang/
+
+require 'test/unit'
+require 'wang'
+require 'test/wang_test_server'
+
+$test_server = WANGTestServer.new
+Thread.new do
+	$test_server.start
+end
+
+class WangTest < Test::Unit::TestCase
+	def setup
+		@client = WANG.new(:debug => true, :read_timeout=>0.9) # small read timeout shouldn't fail local tests
+	end
+
+	def test_returns_success
+		status, headers, body = @client.get('http://localhost:8080/')
+		assert_equal 200, status
+	end
+
+	def test_compression
+		status, headers, body = @client.get('http://localhost:8080/test_inflate')
+		assert_equal 'deflate', headers['content-encoding']
+		assert_equal 'inflate worked', body
+
+		status, headers, body = @client.get('http://localhost:8080/test_gzip')
+		assert_equal 'gzip', headers['content-encoding']
+		assert_equal 'gzip worked', body
+	end
+
+	def test_returns_headers_hash
+		status, headers, body = @client.get('http://localhost:8080/')
+		assert headers.is_a?(Hash)
+		assert_equal 'text/html', headers['content-type']
+	end
+
+	def test_supports_custom_ports
+		assert_nothing_raised { @client.get('http://localhost:8080/redirect') }
+	end
+
+	def test_follows_redirect
+		status, headers, body = @client.get('http://localhost:8080/redirect')
+		assert_equal 'http://localhost:8080/redirect', @client.responses.first.uri.to_s
+		assert_equal 'http://localhost:8080/redirected/elsewhere', @client.responses.last.uri.to_s
+		assert_equal 200, status
+		assert_equal "The redirect worked.\n", body
+	end
+
+	def test_posts_data_using_query_string
+		status, headers, body = @client.post('http://localhost:8080/canhaspost', 'mopar=dongs&joux3=king')
+		assert_equal 200, status
+		assert body =~ /mopar => dongs/
+		assert body =~ /joux3 => king/
+	end
+
+	def test_posts_data_using_hash
+		status, headers, body = @client.post('http://localhost:8080/canhaspost', {'mopar'=>'dongs', 'joux3'=>'king'})
+		assert_equal 200, status
+		assert body =~ /mopar => dongs/
+		assert body =~ /joux3 => king/
+	end
+
+	def test_head_http_method
+		status, headers, body = @client.head('http://localhost:8080/whatmethod')
+		assert_equal 'HEAD', headers['method-used']
+	end
+
+	def test_get_http_method
+		status, headers, body = @client.get('http://localhost:8080/whatmethod')
+		assert_equal 'GET', headers['method-used']
+	end
+
+	def test_post_http_method
+		status, headers, body = @client.post('http://localhost:8080/whatmethod', {'some' => 'query'})
+		assert_equal 'POST', headers['method-used']
+	end
+
+	def test_put_http_method
+		status, headers, body = @client.put('http://localhost:8080/whatmethod', {'some' => 'query'})
+		assert_equal 'PUT', headers['method-used']
+	end
+
+	def test_delete_http_method
+		status, headers, body = @client.delete('http://localhost:8080/whatmethod')
+		assert_equal 'DELETE', headers['method-used']
+	end
+
+	def test_head_requests_return_nil_body
+		status, headers, body = @client.head('http://localhost:8080/')
+		assert_equal nil, body
+	end
+
+	def test_delete_requests_return_nil_body
+		status, headers, body = @client.delete('http://localhost:8080/whatmethod')
+		assert_equal nil, body
+	end
+
+	def test_read_timeout
+		assert_raise Timeout::Error do
+			@client.get('http://localhost:8080/timeout')
+		end
+	end
+
+	def test_infinite_redirection
+		@client.get('http://localhost:8080/infiniteredirect')
+	end
+
+	def test_basic_auth
+		status, headers, body = @client.get('http://localhost:8080/basic_auth')
+		assert_equal status, 401 #unauthorized!
+
+		@client.set_auth('tester', 'wanger')
+		status, headers, body = @client.get('http://localhost:8080/basic_auth')
+		assert_equal status, 200
+		assert body =~ /auth successful/
+	end
+
+	def test_cookie_domain
+		cookie = WANG::Cookie.new.parse("x=y; domain=cat.com")
+		assert cookie.match_domain?("cat.com")
+		assert !cookie.match_domain?("cat.com.au")
+		assert !cookie.match_domain?("cat,com") #just incase we are using the regexp '.'
+		assert !cookie.match_domain?("dogeatcat.com")
+		assert !cookie.match_domain?("ihatethat.cat.com")
+
+		cookie = WANG::Cookie.new.parse("x=y; domain=.cat.com")
+		assert cookie.match_domain?("blah.cat.com")
+		assert !cookie.match_domain?("cat.com") #this is what I read in the spec
+		assert !cookie.match_domain?("blah.cat.com.au")
+	end
+
+	def test_cookie_paths
+		cookie = WANG::Cookie.new.parse("x=y; path=/lamo/")
+		assert cookie.match_path?("/lamo")
+		assert !cookie.match_path?("/lamoa")
+		assert cookie.match_path?("/lamo/aaa/bb")
+		assert !cookie.match_path?("/lam")
+		assert !cookie.match_path?("/lam/oo")
+	end
+
+	def test_cookie_setting
+		status, headers, body = @client.get('http://localhost:8080/cookie_check')
+		assert_equal status, 401 #no cookies set
+		
+		status, headers, body = @client.get('http://localhost:8080/cookie_set')
+		assert_equal status, 200
+
+		status, headers, body = @client.get('http://localhost:8080/cookie_check')
+		assert_equal status, 200
+
+		status, headers, body = @client.get('http://localhost:8080/cookie_set2')
+		assert_equal status, 200 #set the same cookie to something else
+
+		status, headers, body = @client.get('http://localhost:8080/cookie_check')
+		assert_equal status, 401 #wrong value because we set it again
+
+		status, headers, body = @client.get('http://localhost:8080/cookie_check2')
+		assert_equal status, 200
+	end
+
+	def test_cookie_expiry
+		status, headers, body = @client.get('http://localhost:8080/cookie_set_expired')
+		assert_equal status, 200
+		
+		status, headers, body = @client.get('http://localhost:8080/cookie_check')
+		assert_equal status, 401 #wang should remove the cookie since it expired an hour ago
+
+		status, headers, body = @client.get('http://localhost:8080/cookie_set_nonexpired')
+		assert_equal status, 200
+
+		status, headers, body = @client.get('http://localhost:8080/cookie_check')
+		assert_equal status, 200 #wang should accept the cookie and send it, because it still has an hour till expiry
+	end
+end

data/test/wang_test_server.rb

@@ -0,0 +1,143 @@
+# vim: set noet:
+#
+# WANG - Web Access with No Grief
+#   http://github.com/kamu/wang/
+
+require 'webrick'
+require 'stringio'
+require 'zlib'
+
+class HTTPMethodServlet < WEBrick::HTTPServlet::AbstractServlet
+	%w(HEAD GET POST PUT DELETE).each do |http_method|
+		define_method("do_#{http_method}") do |request, response|
+			response['Method-Used'] = request.request_method
+			unless request.request_method == 'DELETE'
+				response.body = 'Some meaningless body'
+			end
+			raise WEBrick::HTTPStatus::OK
+		end
+	end
+end
+
+class WANGTestServer
+	class BlackHole
+		def <<(x)
+		end
+	end
+
+	def initialize
+		log = WEBrick::Log.new(BlackHole.new)
+		@server = WEBrick::HTTPServer.new(:Port => 8080, :AccessLog => [], :Logger => log)
+
+		@server.mount_proc('/redirect') do |request, response|
+			response['Location'] = '/redirected/elsewhere'
+			raise WEBrick::HTTPStatus::MovedPermanently
+		end
+		@server.mount_proc('/redirected/elsewhere') do |request, response|
+			response.body = "The redirect worked.\n"
+			response['Content-Type'] = 'text/plain'
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/') do |request, response|
+			response.body = "<html><head><title>hi</title></head><body><p>Hullo!</p></body></html>"
+			response['Content-Type'] = 'text/html'
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/canhaspost') do |request, response|
+			response.body = request.query.map do |key, val|
+				"#{key} => #{val}"
+			end.join("\n")
+			response['Content-Type'] = 'text/plain'
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/timeout') do |request, response|
+			sleep 1
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/infiniteredirect') do |request, response|
+			response['Location'] = '/infiniteredirect'
+			raise WEBrick::HTTPStatus::TemporaryRedirect
+		end
+		@server.mount_proc('/basic_auth') do |request, response|
+			WEBrick::HTTPAuth.basic_auth(request, response, "WANG basic HTTP auth test") {|user, pass|
+				user == 'tester' && pass == 'wanger'
+			}     
+			response.body = "Basic auth successful!"
+			raise WEBrick::HTTPStatus::OK
+		end
+		@htdigest = WEBrick::HTTPAuth::Htdigest.new('test/htdigest')
+		@authenticator = WEBrick::HTTPAuth::DigestAuth.new(
+			:UserDB => @htdigest,
+			:Realm => 'WANG digest HTTP auth test'
+		)
+		@server.mount_proc('/digest_auth') do |request, response|	
+			@authenticator.authenticate(request, response)		
+			response.body = "Digest auth successful!"
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount('/whatmethod', HTTPMethodServlet)
+		@server.mount_proc('/cookie_check') do |request, response|
+			request.cookies.each do |cookie|
+				raise WEBrick::HTTPStatus::OK if cookie.name.eql?("wangcookie") and cookie.value.eql?("getyerhandoffmywang")
+			end
+			raise WEBrick::HTTPStatus::Unauthorized
+		end
+		@server.mount_proc('/cookie_set') do |request, response|
+			cookie = WEBrick::Cookie.new('wangcookie', 'getyerhandoffmywang')
+			response.cookies << cookie
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/cookie_set2') do |request, response|
+			cookie = WEBrick::Cookie.new('wangcookie', 'touchmywang')
+			response.cookies << cookie
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/cookie_check2') do |request, response|
+			request.cookies.each do |cookie|
+				raise WEBrick::HTTPStatus::OK if cookie.name.eql?("wangcookie") and cookie.value.eql?("touchmywang")
+			end
+			raise WEBrick::HTTPStatus::Unauthorized
+		end
+		@server.mount_proc('/cookie_set_expired') do |request, response|
+			cookie = WEBrick::Cookie.new('wangcookie', 'getyerhandoffmywang')
+			cookie.expires = (Time.now - 60*60*1)
+			response.cookies << cookie
+			raise WEBrick::HTTPStatus::OK
+		end
+
+		@server.mount_proc('/cookie_set_nonexpired') do |request, response|
+			cookie = WEBrick::Cookie.new('wangcookie', 'getyerhandoffmywang')
+			cookie.expires = (Time.now + 60*60*1)
+			response.cookies << cookie
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/test_inflate') do |request, response|
+			response['content-encoding'] = 'deflate'
+			response.body = Zlib::Deflate.deflate("inflate worked")
+			raise WEBrick::HTTPStatus::OK
+		end
+		@server.mount_proc('/test_gzip') do |request, response|
+			response['content-encoding'] = 'gzip'
+			output = StringIO.open('', 'w')
+			gz = Zlib::GzipWriter.new(output)
+			gz.write("gzip worked")
+			gz.close
+			response.body = output.string
+			raise WEBrick::HTTPStatus::OK
+		end
+	end
+
+	def start
+		@server.start
+	end
+
+	def shutdown
+		@server.shutdown
+	end
+end
+
+if __FILE__ == $0
+	server = WANGTestServer.new
+	trap('INT') { server.shutdown }
+	server.start
+end

data/wang.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+	s.platform = Gem::Platform::RUBY
+	s.name = 'wang'
+	s.version = "0.02"
+	s.summary = "Web Access with No Grief."
+	s.authors = ["Kamu", "Joux3"]
+	s.email = "mr.kamu@gmail.com"
+	s.homepage = "http://github.com/kamu/wang/tree"
+	s.requirements << 'none'
+	s.require_path = 'lib'
+	s.files = ["rakefile", "wang.gemspec", "lib/wang.rb", "test/wang_test.rb", "test/wang_test_server.rb", "test/htdigest"]
+	s.test_files = ["test/wang_test.rb"]
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: kamu-wang
+version: !ruby/object:Gem::Version 
+  version: "0.02"
+platform: ruby
+authors: 
+- Kamu
+- Joux3
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-05 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mr.kamu@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rakefile
+- wang.gemspec
+- lib/wang.rb
+- test/wang_test.rb
+- test/wang_test_server.rb
+- test/htdigest
+has_rdoc: false
+homepage: http://github.com/kamu/wang/tree
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- none
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Web Access with No Grief.
+test_files: 
+- test/wang_test.rb