manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/spec/helper/requester.rb

@@ -1,63 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Requester
-  def get url = '/', hash = {}
-    request(:get, url, hash)
-  end
-
-  def post url = '/', hash = {}
-    request(:post, url, hash)
-  end
-
-  def request method, url, hash = {}
-    http = SimpleHttp.new(url2uri(url))
-    if method == :get and not hash.empty?
-      http.uri.query = hash.map{|k,v| "#{k}=#{v}"}.join('&')
-      hash = {}
-    end
-
-    puts "#{method.to_s.upcase} => #{http.uri}"
-    http.send(method, hash).strip
-  end
-
-  def epost url = '/', hash = {}
-    erequest(:post, url, hash)
-  end
-
-  def eget url = '/', hash = {}
-    erequest(:get, url, hash)
-  end
-
-  def erequest method, url, hash = {}
-    response = request(method, url, hash)
-    eval(response)
-  rescue Object => ex
-    p :response => response
-    ex.message
-  end
-
-  def hget(url = '/', hash = {})
-    @response = get(url, hash)
-    @body = @response.body
-    @status = @response.status
-    Hpricot(@body)
-  end
-
-  def hpost(url = '/', hash = {})
-    @response = post(url, hash)
-    @body = @response.body
-    @status = @response.status
-    Hpricot(@body)
-  end
-
-  def url2uri url
-    uri = URI.parse(url)
-    #p uri.methods.sort.grep(/=/)
-    uri.scheme = 'http'
-    uri.host = 'localhost'
-    uri.port = Ramaze::Global.port
-    uri.path = "/#{url}".squeeze('/')
-    uri
-  end
-end

data/lib/ramaze/spec/helper/simple_http.rb

@@ -1,434 +0,0 @@
-=begin
-This package is copyrighted free software by Tim Becker <tim@kuriositaet.de>.
-You can redistribute it and/or modify it under either the terms of the GPL
-(see COPYING.txt file), or the conditions below:
-
-  1. You may make and give away verbatim copies of the source form of the
-     software without restriction, provided that you duplicate all of the
-     original copyright notices and associated disclaimers.
-
-  2. You may modify your copy of the software in any way, provided that
-     you do at least ONE of the following:
-
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-	  modifications to Usenet or an equivalent medium, or by allowing
-	  the author to include your modifications in the software.
-
-       b) use the modified software only within your corporation or
-          organization.
-
-       c) rename any non-standard executables so the names do not conflict
-	  with standard executables, which must also be provided.
-
-       d) make other distribution arrangements with the author.
-
-  3. You may distribute the software in object code or executable
-     form, provided that you do at least ONE of the following:
-
-       a) distribute the executables and library files of the software,
-	  together with instructions (in the manual page or equivalent)
-	  on where to get the original distribution.
-
-       b) accompany the distribution with the machine-readable source of
-	  the software.
-
-       c) give non-standard executables non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  4. You may modify and include the part of the software into any other
-     software (possibly commercial).  But some files in the distribution
-     are not written by the author, so that they are not under this terms.
-
-     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
-     files under the ./missing directory.  See each file for the copying
-     condition.
-
-  5. The scripts and library files supplied as input to or produced as
-     output from the software do not automatically fall under the
-     copyright of the software, but belong to whomever generated them,
-     and may be sold commercially, and may be aggregated with this
-     software.
-
-  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     PURPOSE.
-=end
-
-require 'net/http'
-require 'net/https'
-require 'uri'
-require 'cgi'
-
-
-# Wrapper around ruby's standard net/http classes. Currently, only GET
-# and POST https methods are supported. `SimpleHttp` provides class
-# methods `get` and `post` to handle basic functionality. In case more
-# complicated requests need to be made or default settings need to be
-# overriden, it's possible to instantiate `SimpleHttp` and use instance
-# methods `get` and `put`.
-#
-#
-# Features:
-#
-# * Handles Redirects automatically
-# * Proxy used transparently if http_proxy environment variable is
-#   set.
-# * SSL handled automatically
-# * fault tolerant uri, e.g. all of these would work:
-# 	"www.example.com", "www.example.com/", "http://www.example.com"
-#
-# Some usage examples:
-#		# plain GET (using class methods)
-#		SimpleHttp.get "www.example.com"
-#
-#		# POST using the instance methods
-#		uri = URI.parse "https://www.example.com/index.html"
-#		sh = SimpleHttp uri
-#		sh.set_proxy "my.proxy", "8080"
-#		sh.post {"query" => "query_data"}
-#
-#		# POST using class methods.
-#		binaryData = getImage
-#		SimpleData.post binaryData, "image/png"
-#
-#		# GET requst with a custom request_header
-#		sh = SimpleHttp.new "http://www.example.com"
-#		sh.request_headers= {'X-Special-Http-Header'=>'my-value'}
-#		sh.get
-class SimpleHttp
-
-	VERSION='0.1.1'
-
-	attr_accessor :proxy_host, :proxy_port, :proxy_user, :proxy_pwd, :uri, :request_headers, :response_headers, :response_handlers, :follow_num_redirects
-
-	RESPONSE_HANDLERS = {
-		Net::HTTPResponse => lambda { |request, response, http|
-			response.each_header {|key, value|
-				http.response_headers[key]=value
-			}
-			raise response.to_s
-		},
-		Net::HTTPSuccess => lambda { |request, response, http|
-			response.each_header {|key, value|
-				http.response_headers[key]=value
-			}
-			return response.body
-		},
-		Net::HTTPRedirection => lambda { |request, response, http|
-			raise "too many redirects!" unless http.follow_num_redirects > 0
-
-			# create a new SimpleHttp for the location
-			# refered to decreasing the remaining redirects
-			# by one.
-			sh = SimpleHttp.new response['location']
-			sh.follow_num_redirects = http.follow_num_redirects-1
-
-			# copy the response handlers used in the current
-			# request in case they were non standard.
-			sh.response_handlers = http.response_handlers
-
-			# copy the request headers
-			sh.request_headers  = http.request_headers
-			sh.response_headers = http.response_headers
-
-      # copy host and port
-      sh.uri.host = http.uri.host
-      sh.uri.port = http.uri.port
-
-			# http doesn't permit redirects for methods
-			# other than GET of HEAD, so we complain in case
-			# we get them in response to a POST request. (Or
-			# anything other than GET, for that matter.)
-
-      case request
-      when Net::HTTP::Get
-        sh.get
-      when Net::HTTP::Post
-        sh.post
-			else
-				raise "Not a valid HTTP method for redirection: #{request.class}"
-			end
-		}
-
-	}
-
-	# SimpleHttp can either be used directly through the +get+ and
-	# +post+ class methods or be instantiated, in case you need to
-	# to add custom behaviour to the requests.
-	#
-	# @param may be a URI or a String.
-	#
-	# Example:
-	# 	http = SimpleHttp.new(URI.parse("http://www.example.com"))
-	# 	http = SimpleHttp.new "www.example.com"
-	# 	http = SimpleHttp.new "http://usr:pwd@www.example.com:1234"
-	def initialize uri
-		set_proxy ENV['http_proxy'] if ENV['http_proxy']
-
-		if uri.class == String
-
-			unless uri =~ /^https?:\/\//
-				uri = "http://#{uri}"
-			end
-
-			uri = URI.parse uri
-
-		end
-		@uri = uri
-		if !@uri.path || "" == @uri.path.strip
-			@uri.path="/"
-		end
-
-
-		@request_headers={}
-		@response_headers={}
-		@response_handlers=RESPONSE_HANDLERS.clone
-		@follow_num_redirects=3
-
-		if @uri.user
-			basic_authentication @uri.user, @uri.password
-		end
-
-	end
-
-	#
-	# Provides facilities to perform http basic authentication. You
-	# don't need to provide +usr+ and +pwd+ if they are already included
-	# in the uri, i.e. http://user:password@www.example.com/
-	#
-
-	def basic_authentication usr, pwd
-		str = ["#{usr}:#{pwd}"].pack("*m")
-		str = "Basic #{str}"
-		@request_headers["Authorization"]=str
-	end
-
-	#
-	# this method can be used to register response handlers for specific
-	# http responses in case you need to override the default behaviour.
-	# Defaults are:
-	#
-	# 	HTTPSuccess : return the body of the response
-	# 	HTTPRedirection : follow the redirection until success
-	# 	Others : raise an exception
-	#
-	# `clazz` is the subclass of HTTPResponse (or HTTPResponse in case you
-	# want to define "default" behaviour) that you are registering the
-	# handler for.
-	#
-	# `block` is the handler itself, if a response of the appropriate class
-	# is received, `block` is called with three parameters: the the
-	# Net::HTTPRequest, the actual HTTPResponse object that was received
-	# and a reference to the instance of `SimpleHttp` that is executing the
-	# call.
-	#
-	# example:
-	#
-	# 	# to override the default action of following a HTTP
-	# 	# redirect, you could register the folllowing handler:
-	#
-	# 	sh = SimpleHttp "www.example.com"
-	# 	sh.register_response_handler Net::HTTPRedirection {|request, response, shttp|
-	# 		response['location']
-	# 	}
-	#
-
-	def register_response_handler clazz, &block
-		c = clazz
-	       	while c != Object
-			# completely unnecessary sanity check to make sure parameter
-			# `clazz` is in fact a HTTPResponse ...
-			if c == Net::HTTPResponse
-				@response_handlers[clazz]=block
-				return
-			end
-			c = c.superclass
-		end
-
-		raise "Trying to register a response handler for non-response class: #{clazz}"
-	end
-
-	#
-	#	Set the proxy to use for the http request.
-	# 	Note that you don't need to set the proxy in case the
-	# 	`http_proxy` environment variable is set. To override
-	#	previous proxy settings and connect directly, call
-	#	`set_proxy nil`
-	#
-	#	usage:
-	#		http = SimpleHttp.new "www.example.com"
-	#
-	#		http.set_proxy "http://proxy:8000"
-	#	or:
-	#		http.set_proxy(URI.parse("http://proxy:8000"))
-	#	or:
-	#		http.set_proxy 'proxy', '8000', 'my_user', 'secret'
-	#	or:
-	#		http.set_proxy nil # to override previous proxy
-	#		settings and make the request directly.
-	#
-
-
-	def set_proxy proxy, port=nil, user=nil, pwd=nil
-
-
-		if !proxy
-			@proxy_host=@proxy_port=@proxy_user=@proxy_pwd=nil
-			return
-		end
-
-		if proxy.class == String
-			if !port && !user && !pwd
-				proxy = URI.parse(proxy)
-			else
-				@proxy_host= host
-				@proxy_port= port
-				@proxy_user= user
-				@proxy_pwd = pwd
-			end
-		end
-
-		if proxy.class == URI::HTTP
-			@proxy_host= proxy.host
-			@proxy_port= proxy.port
-			@proxy_user= proxy.user
-			@proxy_pwd = proxy.password
-		end
-	end
-
-	# interal
-	# Takes a HTTPResponse (or subclass) and determines how to
-	# handle the response. Default behaviour is:
-	#
-	# 	HTTPSuccess : return the body of the response
-	# 	HTTPRedirection : follow the redirect until success.
-	# 	default : raise the HTTPResponse.
-	#
-	# the default behaviour can be overidden by registering a
-	# response handler using the `register_response_handler` method.
-	#
-
-	def handle_response http_request, http_response
-		raise "Not a Net::HTTPResponse" unless http_response.is_a? Net::HTTPResponse
-
-		c = http_response.class
-		while c!=Object
-			# the response_handlers hash contains a handler
-			# for the specific response class.
-			if @response_handlers[c]
-				return @response_handlers[c].call(http_request, http_response, self)
-			end
-
-			c=c.superclass
-		end
-
-		# if we reached this place, no handler was registered
-		# for this response. default is to return the response.
-
-		return http_response
-	end
-
-	# internal
-	def do_http request
-		response = nil
-
-		http = Net::HTTP.new(@uri.host, @uri.port, proxy_host,
-			proxy_port, proxy_user, proxy_pwd)
-		http.use_ssl = @uri.scheme == 'https'
-
-		# add custom request headers.
-
-		@request_headers.each {|key,value|
-			request[key]=value
-		}
-
-		handle_response(request, http.request(request))
-	end
-
-	# internal
-	def make_query query
-		return query unless query && query.class == Hash
-    query.inject([]) do |s, (key, value)|
-			s + [CGI::escape(key) + "=" + CGI::escape(value)]
-    end.join('&')
-	end
-
-	# Make a simple GET request to the provided URI.
-	#
-	# Example:
-	# 	puts(SimpleHttp.get("www.example.com"))
-	def self.get uri, query=nil
-		http = SimpleHttp.new uri
-		http.get query
-	end
-
-	# Make a POST request to the provided URI.
-	#
-	# Example:
-	# 	puts(SimpleHttp.post("www.example.com", "query"=>"my_query"))
-	#
-	# Alternatively, you can post any sort of data, but will have to
-	# set the appriate content_type:
-	#
-	# 	SimpleHttp.post("http://www.example.com/", binary_data, "img/png")
-
-	def self.post uri, query=nil, content_type='application/x-www-form-urlencoded'
-		http = SimpleHttp.new uri
-		http.post query, content_type
-	end
-
-	# Call the +get+ method as an instance method if you need to
-	# modify the default behaviour of the library, or set special
-	# headers:
-	#
-	# 	http = SimpleHttp.new "www.example.com"
-	# 	http.request_headers["X-Special"]="whatever"
-	# 	str = http.get
-	def get query = nil
-		if (query = make_query query)
-			@uri.query = @uri.query ? @uri.query+"&"+query : query
-		end
-		full_path = @uri.path + (@uri.query ? "?#{@uri.query}" : "")
-
-		req = Net::HTTP::Get.new(full_path)
-		# puts Net::HTTP::Proxy(@proxy_host, @proxy_port, @proxy_user, @proxy_pwd).get(@uri)
-		do_http req
-	end
-
-	#
-	#	Post the query data to the url.
-	#	The body of the request remains empty if query=nil.
-	#	In case `query` is a `Hash`, it's assumed that we are
-	#	sending a form.
-	#	In case `query` is a `String`, it's also assumed that a
-	#	form is being sent, UNLESS the `content_type` parameter
-	#	is set.
-	#
-	def post query=nil, content_type='application/x-www-form-urlencoded'
-		req = Net::HTTP::Post.new(@uri.path)
-
-		req.body= make_query query if query
-		req.content_type=content_type if query
-		req.content_length=query ? req.body.length : 0
-
-		do_http req
-	end
-
-end
-
-#ht = SimpleHttp.new "http://www.google.com/aldfksjaldskjfalskjfdlk"
-##ht.register_response_handler(Net::HTTPRedirection) {|req, res, ht| puts res['location']}
-#puts ht.get.class
-##puts(ht.get("q"=>"bla"))
-#
-##puts (SimpleHttp.get "http://www.google.com")
-#
-#['http://www.google.com/', 'www.google.com', 'https://www.google.com'].each {|u|
-#	SimpleHttp.new u
-#}
-##puts ht.post
-

data/lib/ramaze/spec/helper.rb

@@ -1,135 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-begin
-  require 'rubygems'
-rescue LoadError
-end
-
-require 'ramaze'
-require 'ramaze/spec/helper/bacon'
-
-# Invoke ramaze with a set of default options suitable for testing.
-# you may pass your options that will override the defaults.
-class Bacon::Context
-  # Skip start from required files
-  Ramaze.trait[:started] = true
-
-  def ramaze(options = {})
-    options = {
-      :adapter      => false,
-      :run_loose    => true,
-      :error_page   => false,
-      :port         => 7007,
-      :host         => '127.0.0.1',
-      :sourcereload => false,
-      :origin       => :spec,
-    }.merge(options)
-
-    Ramaze.start!(options)
-  end
-end
-
-SPEC_REQUIRE_DEPENDENCY = {
-  'sequel' => %w[sqlite3 sequel_model sequel_core]
-}
-
-# require each of the following and rescue LoadError, telling you why it failed.
-def spec_require(*following)
-  following << following.map{|f| SPEC_REQUIRE_DEPENDENCY[f] }
-  following.flatten.uniq.compact.reverse.each do |file|
-    require file.to_s
-  end
-rescue LoadError => ex
-  puts ex
-  puts "Can't run #{$0}: #{ex}"
-  puts "Usually you should not worry about this failure, just install the"
-  puts "library and try again (if you want to use that feature later on)"
-  exit
-end
-
-shared "http" do
-  require 'ramaze/spec/helper/mock_http'
-  extend MockHTTP
-end
-
-shared 'browser' do
-  require 'ramaze/spec/helper/simple_http'
-  require 'ramaze/spec/helper/browser'
-end
-
-shared 'requester' do
-  require 'ramaze/spec/helper/mock_http'
-  require 'ramaze/spec/helper/requester'
-  extend Requester
-  extend MockHTTP
-end
-
-# make it easier to use XPATH on the MockResponse#body - in cases you can't use
-# Hpricot or if you want to keep dependencies down
-shared 'xpath' do
-  behaves_like 'http'
-
-  require 'rexml/document'
-  require 'rexml/xpath'
-
-  class Rack::MockResponse
-    # Delegate to REXML::XPath::match
-    def match(xpath = '*')
-      REXML::XPath::match(REXML::Document.new(body), xpath)
-    end
-    alias / match
-    alias search match
-
-    # Delegate to REXML::XPath::first
-    def first(xpath = '*')
-      REXML::XPath::first(REXML::Document.new(body), xpath)
-    end
-    alias at first
-
-    # Delegate to REXML::XPath::each
-    def each(xpath = '*', &block)
-      REXML::XPath::each(REXML::Document.new(body), xpath, &block)
-    end
-  end
-
-  # Delegate to REXML::XPath::match
-  def xp_match(obj, xpath = '*', &block)
-    REXML::XPath::match(rexml_doc(obj), xpath, &block)
-  end
-  alias xp_search xp_match
-
-  # Delegate to REXML::XPath::first
-  def xp_first(obj, xpath = '*', &block)
-    REXML::XPath::first(rexml_doc(obj), xpath, &block)
-  end
-  alias xp_at xp_first
-
-  # Delegate to REXML::XPath::each
-  def xp_each(obj, xpath = '*', &block)
-    REXML::XPath::each(rexml_doc(obj), xpath, &block)
-  end
-
-  # Delegate to REXML::Document.new - return the obj if it's already an
-  # instance.
-  def rexml_doc(obj)
-    case obj
-    when REXML::Document, REXML::Element
-      obj
-    else
-      REXML::Document.new(obj)
-    end
-  end
-end
-
-shared 'resolve' do
-  # shortcut for Ramaze::Controller::resolve
-  def resolve(url)
-    Ramaze::Controller::resolve(url)
-  end
-
-  # Shortcut to stack on the instance of Action return from resolve
-  def stack(url, &block)
-    resolve(url).stack(&block)
-  end
-end