astrotrain 0.5.4 → 0.6.0

data/lib/vendor/rest-client/lib/rest_client.rb

@@ -1,188 +0,0 @@
-require 'uri'
-require 'net/https'
-
-require File.dirname(__FILE__) + '/rest_client/resource'
-require File.dirname(__FILE__) + '/rest_client/request_errors'
-require File.dirname(__FILE__) + '/rest_client/payload'
-require File.dirname(__FILE__) + '/rest_client/net_http_ext'
-
-# This module's static methods are the entry point for using the REST client.
-#
-#   # GET
-#   xml = RestClient.get 'http://example.com/resource'
-#   jpg = RestClient.get 'http://example.com/resource', :accept => 'image/jpg'
-#
-#   # authentication and SSL
-#   RestClient.get 'https://user:password@example.com/private/resource'
-#
-#   # POST or PUT with a hash sends parameters as a urlencoded form body
-#   RestClient.post 'http://example.com/resource', :param1 => 'one'
-#
-#   # nest hash parameters
-#   RestClient.post 'http://example.com/resource', :nested => { :param1 => 'one' }
-#
-#   # POST and PUT with raw payloads
-#   RestClient.post 'http://example.com/resource', 'the post body', :content_type => 'text/plain'
-#   RestClient.post 'http://example.com/resource.xml', xml_doc
-#   RestClient.put 'http://example.com/resource.pdf', File.read('my.pdf'), :content_type => 'application/pdf'
-#
-#   # DELETE
-#   RestClient.delete 'http://example.com/resource'
-#
-# For live tests of RestClient, try using http://rest-test.heroku.com, which echoes back information about the rest call:
-#
-#   >> RestClient.put 'http://rest-test.heroku.com/resource', :foo => 'baz'
-#   => "PUT http://rest-test.heroku.com/resource with a 7 byte payload, content type application/x-www-form-urlencoded {\"foo\"=>\"baz\"}"
-#
-module RestClient
-	def self.get(url, headers={}, &b)
-		Request.execute(:method => :get,
-			:url => url,
-			:headers => headers, &b)
-	end
-
-	def self.post(url, payload, headers={}, &b)
-		Request.execute(:method => :post,
-			:url => url,
-			:payload => payload,
-			:headers => headers, &b)
-	end
-
-	def self.put(url, payload, headers={}, &b)
-		Request.execute(:method => :put,
-			:url => url,
-			:payload => payload,
-			:headers => headers, &b)
-	end
-
-	def self.delete(url, headers={}, &b)
-		Request.execute(:method => :delete,
-			:url => url,
-			:headers => headers, &b)
-	end
-
-	# Internal class used to build and execute the request.
-	class Request
-		attr_reader :method, :url, :headers, :user, :password
-
-		def self.execute(args, &b)
-			new(args).execute(&b)
-		end
-
-		def initialize(args)
-			@method = args[:method] or raise ArgumentError, "must pass :method"
-			@url = args[:url] or raise ArgumentError, "must pass :url"
-			@payload = Payload.generate(args[:payload] || '')
-			@headers = args[:headers] || {}
-			@user = args[:user]
-			@password = args[:password]
-		end
-
-		def execute(&b)
-			execute_inner(&b)
-		rescue Redirect => e
-			@url = e.url
-			execute(&b)
-		end
-
-		def execute_inner(&b)
-			uri = parse_url_with_auth(url)
-			transmit(uri, net_http_class(method).new(uri.request_uri, make_headers(headers)), payload, &b)
-		end
-
-		def make_headers(user_headers)
-			final = {}
-			merged = default_headers.merge(user_headers)
-			merged.keys.each do |key|
-				final[key.to_s.gsub(/_/, '-').capitalize] = merged[key]
-			end
-			final
-		end
-
-		def net_http_class(method)
-			Net::HTTP.const_get(method.to_s.capitalize)
-		end
-
-		def parse_url(url)
-			url = "http://#{url}" unless url.match(/^http/)
-			URI.parse(url)
-		end
-
-		def parse_url_with_auth(url)
-			uri = parse_url(url)
-			@user = uri.user if uri.user
-			@password = uri.password if uri.password
-			uri
-		end
-
-		def process_payload(p=nil, parent_key=nil)
-			unless p.is_a?(Hash)
-				p
-			else
-				@headers[:content_type] ||= 'application/x-www-form-urlencoded'
-				p.keys.map do |k|
-					key = parent_key ? "#{parent_key}[#{k}]" : k
-					if p[k].is_a? Hash
-						process_payload(p[k], key)
-					else
-						value = URI.escape(p[k].to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-						"#{key}=#{value}"
-					end
-				end.join("&")
-			end
-		end
-
-		def transmit(uri, req, payload, &b)
-			setup_credentials(req)
-
-			net = Net::HTTP.new(uri.host, uri.port)
-			net.use_ssl = uri.is_a?(URI::HTTPS)
-			net.start do |http|
-				## Ok. I know this is weird but it's a hack for now
-				## this lets process_result determine if it should read the body
-				## into memory or not
-				process_result(http.request(req, payload || "", &b), &b)
-			end
-		rescue EOFError
-			raise RestClient::ServerBrokeConnection
-		rescue Timeout::Error
-			raise RestClient::RequestTimeout
-		ensure
-			payload.close
-		end
-
-		def setup_credentials(req)
-			req.basic_auth(user, password) if user
-		end
-
-		def process_result(res, &b)
-			if %w(200 201 202).include? res.code
-				return res.body unless b
-			elsif %w(301 302 303).include? res.code
-				url = res.header['Location']
-
-				if url !~ /^http/
-					uri = URI.parse(@url)
-					uri.path = "/#{url}".squeeze('/')
-					url = uri.to_s
-				end
-
-				raise Redirect, url
-			elsif res.code == "401"
-				raise Unauthorized
-			elsif res.code == "404"
-				raise ResourceNotFound
-			else
-				raise RequestFailed, res
-			end
-		end
-		
-		def payload
-			@payload
-		end
-
-		def default_headers
-			@payload.headers.merge({ :accept => 'application/xml' })
-		end
-	end
-end

data/lib/vendor/rest-client/lib/rest_client/net_http_ext.rb

@@ -1,23 +0,0 @@
-#
-# Replace the request method in Net::HTTP to sniff the body type
-# and set the stream if appropriate
-#
-# Taken from:	
-# http://www.missiondata.com/blog/ruby/29/streaming-data-to-s3-with-ruby/
-
-Net::HTTP.ssl_context_accessor(:tmp_dh_callback)
-
-module Net
-	class HTTP
-		alias __request__ request
-
-		def request(req, body=nil, &block)
-			if body != nil && body.respond_to?(:read)
-				req.body_stream = body
-				return __request__(req, nil, &block)
-			else
-				return __request__(req, body, &block)
-			end
-		end
-	end
-end

data/lib/vendor/rest-client/lib/rest_client/payload.rb

@@ -1,185 +0,0 @@
-require "tempfile"
-require "stringio"
-
-module RestClient
-	module Payload
-		extend self
-
-		def generate(params)
-			if params.is_a?(String)
-				Base.new(params)
-			elsif params.delete(:multipart) == true || 
-				params.any? { |_,v| v.respond_to?(:path) && v.respond_to?(:read) }
-				Multipart.new(params)
-			else
-				UrlEncoded.new(params)
-			end
-		end
-
-		class Base
-			def initialize(params)
-				build_stream(params)
-			end
-
-			def build_stream(params)
-				@stream = StringIO.new(params)
-				@stream.seek(0)
-			end
-
-			def read(bytes=nil)
-				@stream.read(bytes)
-			end
-			alias :to_s :read
-
-			def escape(v)
-				URI.escape(v.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-			end
-
-			def headers
-				{ 'Content-Length' => size.to_s }
-			end
-
-			def size
-				@stream.size
-			end
-			alias :length :size
-
-			def close
-				@stream.close
-			end
-		end
-
-		class UrlEncoded < Base
-			def build_stream(params)
-				@stream = StringIO.new(params.map do |k,v| 
-					"#{escape(k)}=#{escape(v)}"
-				end.join("&"))
-				@stream.seek(0)
-			end
-
-			def headers
-				super.merge({ 'Content-Type' => 'application/x-www-form-urlencoded' })
-			end
-		end
-
-		class Multipart < Base
-			EOL = "\r\n"
-
-			def build_stream(params)
-				b = "--#{boundary}"
-
-				@stream = Tempfile.new("RESTClient.Stream.#{rand(1000)}")
-				@stream.write(b)
-				params.each do |k,v|
-				  @stream.write(EOL)
-					if v.respond_to?(:read) && v.respond_to?(:path)
-						create_file_field(@stream, k,v)
-					else
-						create_regular_field(@stream, k,v)
-					end
-					@stream.write(EOL + b)
-				end
-				@stream.write('--')
-				@stream.write(EOL)
-				@stream.seek(0)
-			end
-
-			def create_regular_field(s, k, v)
-				s.write("Content-Disposition: multipart/form-data; name=\"#{k}\"")
-				s.write(EOL)
-				s.write(EOL)
-				s.write(v)
-			end
-
-			def create_file_field(s, k, v)
-				begin
-					s.write("Content-Disposition: multipart/form-data; name=\"#{k}\"; filename=\"#{v.path}\"#{EOL}")
-					s.write("Content-Type: #{mime_for(v.path)}#{EOL}")
-					s.write(EOL)
-					while data = v.read(8124)
-						s.write(data)
-					end
-				ensure
-					v.close
-				end
-			end
-
-			def mime_for(path)
-				ext = File.extname(path)[1..-1]
-				MIME_TYPES[ext] || 'text/plain'
-			end
-
-			def boundary
-				@boundary ||= rand(1_000_000).to_s
-			end
-
-			def headers
-				super.merge({'Content-Type' => %Q{multipart/form-data; boundary="#{boundary}"}})
-			end
-
-			def close
-				@stream.close
-			end
-		end
-
-		# :stopdoc:
-		# From WEBrick.
-		MIME_TYPES = {
-			"ai"    => "application/postscript",
-			"asc"   => "text/plain",
-			"avi"   => "video/x-msvideo",
-			"bin"   => "application/octet-stream",
-			"bmp"   => "image/bmp",
-			"class" => "application/octet-stream",
-			"cer"   => "application/pkix-cert",
-			"crl"   => "application/pkix-crl",
-			"crt"   => "application/x-x509-ca-cert",
-			"css"   => "text/css",
-			"dms"   => "application/octet-stream",
-			"doc"   => "application/msword",
-			"dvi"   => "application/x-dvi",
-			"eps"   => "application/postscript",
-			"etx"   => "text/x-setext",
-			"exe"   => "application/octet-stream",
-			"gif"   => "image/gif",
-			"gz"   => "application/x-gzip",
-			"htm"   => "text/html",
-			"html"  => "text/html",
-			"jpe"   => "image/jpeg",
-			"jpeg"  => "image/jpeg",
-			"jpg"   => "image/jpeg",
-			"js"    => "text/javascript",
-			"lha"   => "application/octet-stream",
-			"lzh"   => "application/octet-stream",
-			"mov"   => "video/quicktime",
-			"mpe"   => "video/mpeg",
-			"mpeg"  => "video/mpeg",
-			"mpg"   => "video/mpeg",
-			"pbm"   => "image/x-portable-bitmap",
-			"pdf"   => "application/pdf",
-			"pgm"   => "image/x-portable-graymap",
-			"png"   => "image/png",
-			"pnm"   => "image/x-portable-anymap",
-			"ppm"   => "image/x-portable-pixmap",
-			"ppt"   => "application/vnd.ms-powerpoint",
-			"ps"    => "application/postscript",
-			"qt"    => "video/quicktime",
-			"ras"   => "image/x-cmu-raster",
-			"rb"    => "text/plain",
-			"rd"    => "text/plain",
-			"rtf"   => "application/rtf",
-			"sgm"   => "text/sgml",
-			"sgml"  => "text/sgml",
-			"tif"   => "image/tiff",
-			"tiff"  => "image/tiff",
-			"txt"   => "text/plain",
-			"xbm"   => "image/x-xbitmap",
-			"xls"   => "application/vnd.ms-excel",
-			"xml"   => "text/xml",
-			"xpm"   => "image/x-xpixmap",
-			"xwd"   => "image/x-xwindowdump",
-			"zip"   => "application/zip",
-		}
-		# :startdoc:
-	end
-end

data/lib/vendor/rest-client/lib/rest_client/request_errors.rb

@@ -1,75 +0,0 @@
-module RestClient
-	# This is the base RestClient exception class. Rescue it if you want to
-	# catch any exception that your request might raise
-	class Exception < RuntimeError
-		def message(default=nil)
-			self.class::ErrorMessage
-		end
-	end
-
-	# A redirect was encountered; caught by execute to retry with the new url.
-	class Redirect < Exception
-		ErrorMessage = "Redirect"
-
-		attr_accessor :url
-		def initialize(url)
-			@url = url
-		end
-	end
-
-	# Authorization is required to access the resource specified.
-	class Unauthorized < Exception
-		ErrorMessage = 'Unauthorized'
-	end
-
-	# No resource was found at the given URL.
-	class ResourceNotFound < Exception
-		ErrorMessage = 'Resource not found'
-	end
-
-	# The server broke the connection prior to the request completing.
-	class ServerBrokeConnection < Exception
-		ErrorMessage = 'Server broke connection'
-	end
-
-	# The server took too long to respond.
-	class RequestTimeout < Exception
-		ErrorMessage = 'Request timed out'
-	end
-
-	# The request failed, meaning the remote HTTP server returned a code other
-	# than success, unauthorized, or redirect.
-	#
-	# The exception message attempts to extract the error from the XML, using
-	# format returned by Rails: <errors><error>some message</error></errors>
-	#
-	# You can get the status code by e.http_code, or see anything about the
-	# response via e.response.  For example, the entire result body (which is
-	# probably an HTML error page) is e.response.body.
-	class RequestFailed < Exception
-		attr_accessor :response
-
-		def initialize(response=nil)
-			@response = response
-		end
-
-		def http_code
-			@response.code.to_i if @response
-		end
-
-		def message
-			"HTTP status code #{http_code}"
-		end
-
-		def to_s
-			message
-		end
-	end
-end
-
-# backwards compatibility
-class RestClient::Request
-	Redirect = RestClient::Redirect
-	Unauthorized = RestClient::Unauthorized
-	RequestFailed = RestClient::RequestFailed
-end