http_request.rb 1.0.1

data/Changelog

@@ -0,0 +1,7 @@
+v1.1
+    * new feature: upload or download files by ftp
+
+v1.0
+    * support get, post, put, delete etc. http methods
+    * upload files
+  	* and more...

data/README.rdoc

@@ -0,0 +1,189 @@
+== Introduction
+
+The HttpRequest class is based on the 'net/http' and 'net/ftp' libraries, so the return type is Net::HTTPResponse or Net::FTP when you call get or post or other methods by HttpRequest.xxx or HttpRequest.ftp
+
+== Options
+
+  you can call like HttpRequest.get(options), the options parameter is a hash, support following keys:
+    :url              =>   String, the url you want to request
+    :parameters       =>   String or Hash,  parameters will send to the url
+    :redirect         =>   Boolean, whether support redirect to,  default is true
+    :redirect_limits  =>   Fixnum, maximal times for redirect if enabled
+    :ssl_port         =>   Fixnum, ssl port, default is 443
+    :headers          =>   Hash, you can add some custom http headers
+    :files            =>   for upload files
+
+    # proxy settings
+    :proxy_addr       =>   String, proxy address 
+    :proxy_port       =>   Fixnum, proxy port
+    :proxy_user       =>   String, proxy username
+    :proxy_pass       =>   String, proxy password
+
+== Examples for your ruby program:
+
+include http_request.rb first
+    require '/path/to/http_request.rb'
+
+get 
+    puts HttpRequest.get('http://www.github.com')
+
+get with query string, 4 are same
+    puts HttpRequest.get('http://www.google.com/search?hl=en&q=ruby&start=0&sa=N')
+    puts HttpRequest.get(:url => 'http://www.google.com/search', :parameters => 'hl=en&q=ruby&start=0&sa=N')
+    puts HttpRequest.get({:url => 'http://www.google.com/search', :parameters => 'hl=en&q=ruby&start=0&sa=N'})
+    puts HttpRequest.get({:url => 'http://www.google.com/search', :parameters => {:hl => 'en', :q => 'ruby', :start => 0, :sa => 'N'}})
+
+post with some paramet
+    puts HttpRequest.get(:url => 'http://localhost/test.php', :parameters => 'from=http_request.rb').body
+    puts HttpRequest.get(:url => 'http://localhost/test.php', :parameters => {:name => 'Ruby', :time => 'Now'}).body
+
+also support other http methods, such as put, delete, trace, options, move etc. 
+    HttpRequest.put(:url => 'http://www.example.com', :parameters => 'some=vars')
+    HttpRequest.delete('http://www.example.com/article/1')
+    HttpRequest.trace('http://www.example.com/')
+
+basic authorization
+    HttpRequest.get('http://admin:pass@auth.cnzxh.net/secret/get/file')
+
+proxy support
+    HttpRequest.get(:url => 'http://www.example.com/', :proxy_addr => 'your.proxy.address', :proxy_port => 80)
+    HttpRequest.get(:url => 'http://www.example.com/', :proxy_addr => 'your.proxy.address', :proxy_port => 80, :proxy_user => 'admin', :proxy_pass => '123123')
+
+fetch headers
+    HttpRequest.get('http://www.example.com/').each {|k, v|
+      print "#{k} : #{v}"
+    }
+
+fetch cookies
+    hp = HttpRequest.get('http://www.yahoo.com')
+    hp.cookies.each {|k, v|
+       puts "#{k} => #{v}"
+    }
+
+add cookies into header
+    HttpRequest.get(:url => 'http://www.example.com/', :cookies => {:login => 'Yes', :userid => 101})
+    HttpRequest.get(:url => 'http://www.example.com/', :cookies => 'login=Yes; userId=101')
+
+upload file by post method
+    HttpRequest.post(
+      :url => 'http://localhost/upload.php', 
+      :files => [{
+        :file_name     => 'test.txt',            # original file name, default is rand name such as 0cdex_0
+        :field_name    => 'user_file',           # input field name, default is "files[]"
+        :content_type  => 'text/plain',          # content type, default is application/octet-stream
+        :file_content  => 'Have a nice day!'     # file content
+      }]
+    )
+
+upload more than 1 file
+    files = [
+        {:file_name => 'a.txt', :file_content => 'just for test'},
+        {:file_name => 'b.csv', :file_content => "a,b,c\nd,e,f"}
+    ]
+    HttpRequest.post(
+      :url => 'http://localhost/upload.php',
+      :files => files
+    )
+
+upload files with parameters
+    HttpRequest.post(
+      :url => 'http://localhost/upload.php',
+      :parameters => {:name => 'zhou', :age => '?'},
+      :files => [{:file_content => 'so easy:-)'}]
+    )
+    HttpRequest.post(
+      :url => 'http://localhost/upload.php',
+      :parameters => 'target=php&client=ruby',
+      :files => [{:file_content => 'so easy:-)'}]
+    )
+
+want to upload a binary file such as photo?
+    HttpRequest.post(
+      :url => 'http://localhost/upload.php',
+      :parameters => {:title => 'Nice photo', :description => 'some description here.'},
+      :files => [{:file_name => 'nice.jpg', :field_name => 'photo', :file_content => File.read('/path/to/nice.jpg')}]
+    )
+
+upload file by put method, more can check http://www.php.net/manual/en/features.file-upload.put-method.php
+    HttpRequest.put(
+      :url        => 'http://localhost/upload.php',
+      :parameters => 'file content here'
+    )
+
+== Examples in command line:
+
+You need to do like "chmod +x http_request.rb" first. 
+Usage: ./http_request.rb method url [parameters]
+
+get a file and print the content
+    $./http_request.rb get http://feeds.feedburner.com/RidingRails
+    $./http_request.rb get 'http://www.google.com/search?hl=en&q=ruby&start=0&sa=N'
+
+get but just print header 
+    $./http_request.rb get_only_header http://feeds.feedburner.com/RidingRails
+
+get header and content
+    $./http_request.rb get_with_header http://feeds.feedburner.com/RidingRails
+
+download and save as a file
+    $./http_request.rb http://rubyforge.org/frs/download.php/51094/RMagick-2.9.1.tar.bz2 > rmagick.tar.bz2
+
+post 
+    $./http_request.rb post http://localhost/test.php 'name=Ruby&time=Now'
+
+such as "get_only_header" and "get_with_header", post and other http methods also can do such as "post_only_header", "put_with_header" etc.
+
+== Examples for FTP (since 1.0.1):
+
+download and save to
+    ftp = HttpRequest.ftp(:get, :url => 'ftp://user:pass@my.domain.name/path/to/hello.mp3', :to => '/tmp/hello.mp3')
+
+upload from local
+    ftp = HttpRequest.ftp(:put, :url => 'ftp://user:pass@my.domain.name/path/to/hello.mp3', :from => '/tmp/hello.mp3')
+
+get server info
+    puts HttpRequest.ftp(:status, :url => 'ftp://user:pass@my.domain.name/')
+
+create a new directory (only for last directory)
+    HttpRequest.ftp(:mkdir, :url => 'ftp://user:pass@my.domain.name/path/to/newdir')
+    HttpRequest.ftp(:mkdir, :url => 'ftp://user:pass@my.domain.name/newdir')
+
+remove a directory (only for last directory)
+    HttpRequest.ftp(:mkdir, :url => 'ftp://user:pass@my.domain.name/path/to/willbe_removed_dir')
+
+list files
+    puts HttpRequest.ftp(:list, :url => 'ftp://user:pass@my.domain.name/')
+
+list files as array
+    HttpRequest.ftp(:nlst, :url => 'ftp://my.domain.name/', :username => 'user', :password => 'pass').each {|f|
+      puts f
+    }
+
+anonymous login
+    puts HttpRequest.ftp(:status, :url => 'ftp://my.domain.name/')
+
+working as the "net/ftp" style, need set :close to false
+    ftp = HttpRequest.ftp(:status, :url => 'ftp://user:pass@my.domain.name/', :close => false)
+    puts ftp.response  # get status from the ftp server
+    ftp.chdir('/musics')
+    ftp.getbinaryfile('test.ogg', '/tmp/test.ogg')
+    ftp.close
+
+download multiple files from a directory
+    ftp = HttpRequest.ftp('nlst', :url => 'ftp://user:pass@my.domain.name/mp3/', :close => false)
+    ftp.response.each {|f|
+        puts "downloading....#{f}"
+        ftp.get(f, '/tmp/downloads/' + File.basename(f))
+    }
+    ftp.close
+
+== TODO
+
+  ......
+
+== LATEST VERSION
+  1.0.1
+
+== Author
+   
+   xianhua.zhou<xianhua.zhou at gmail.com>, homepage: http://my.cnzxh.net

data/lib/http_request.rb

@@ -0,0 +1,286 @@
+#!/usr/bin/env ruby
+#
+# == Description
+#
+#   This is a small, lightweight, powerful HttpRequest class based on the 'net/http' and 'net/ftp' libraries, 
+#   it's easy to use to send http request and get response, also can use it as a shell script in command line.
+#
+# == Example
+#
+#   Please read README.rdoc
+#
+# == Version
+# 
+#   v1.0.1
+#
+#   Last Change: 11 Apail, 2009
+#
+# == Author
+#
+#   xianhua.zhou<xianhua.zhou@gmail.com>
+#   homepage: http://my.cnzxh.net
+#
+#
+require 'net/http'
+require 'net/https'
+require 'cgi'
+require 'singleton'
+
+class HttpRequest
+	include Singleton
+
+	def self.http_methods
+    %w{get head post put proppatch lock unlock options propfind delete move copy mkcol trace}
+	end
+
+  # initialize
+	def init_args(method, options)
+		options = {:url => options.to_s} if [String, Array].include? options.class
+		@options = {
+			:ssl_port        => 443,
+			:redirect_limits => 5,
+			:redirect        => true,
+			:url             => nil
+		}
+		@options.merge!(options)
+		@uri = URI(@options[:url])
+    @uri.path = '/' if @uri.path.empty?
+		@headers = {
+      'Host' => @uri.host,
+      'Referer' => @options[:url],
+      'Accept-Language' => 'en-us,zh-cn;q=0.7,en;q=0.3',
+      'Accept-Charset' => 'zh-cn,zh;q=0.5',
+      'Accept' => 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
+      'Cache-Control' => 'max-age=0',
+      'User-Agent' => 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.0.7) Gecko/2009030423 Ubuntu/8.04 (hardy) Firefox/3.0.7',
+      'Connection' => 'keep-alive'
+		}
+
+    # Basic Authenication
+    @headers['Authorization'] = "Basic " + [@uri.userinfo].pack('m').delete!("\r\n") if @uri.userinfo
+
+    # headers
+    @options[:headers].each {|k, v| @headers[k] = v} if @options[:headers].is_a? Hash
+
+    # add cookies if have
+    if @options[:cookies]
+      if @options[:cookies].is_a? Hash
+        cookies = []
+        @options[:cookies].each {|k, v|
+          cookies << "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+        }
+        cookies = cookies.join('; ')
+      else
+        cookies = @options[:cookies].to_s
+      end
+      @headers['Cookie'] = cookies unless cookies.empty?
+    end
+
+    @redirect_times = 0 if @options[:redirect]
+	end
+
+  # send request
+	def request(method, opt)
+		init_args(method, opt)
+		@options[:method] = method
+
+    # for upload files
+    if @options[:files].is_a?(Array) && 'post'.eql?(method)
+      build_multipart
+    else
+      if @options[:parameters].is_a? Hash
+        @options[:parameters] = @options[:parameters].collect{|k, v| 
+          CGI.escape(k.to_s) + '=' + CGI.escape(v.to_s)
+        }.join('&')
+      end
+    end
+
+		http =  if @options[:proxy_addr]
+      if @options[:proxy_user] and @options[:proxy_pass]
+        Net::HTTP::Proxy(@options[:proxy_addr], @options[:proxy_port], @options[:proxy_user], @options[:proxy_pass]).new(@u.host, @u.port)
+      else
+        Net::HTTP::Proxy(@options[:proxy_addr], @options[:proxy_port]).new(@uri.host, @uri.port)
+      end
+    else
+      Net::HTTP.new(@uri.host, @uri.port)
+    end
+
+		# ssl support
+		http.use_ssl = true if @uri.scheme =~ /^https$/i
+
+		# get data by post or get method.
+		response = send_request http
+
+		return response unless @options[:redirect]
+
+		# redirect....===>>>
+		case response
+		when Net::HTTPRedirection
+			@options[:url] = if response['location'] =~ /^http[s]*:\/\//i
+        response['location']
+      else
+        @uri.scheme + '://' + @uri.host + ':' + @uri.port.to_s + response['location']
+      end
+			@redirect_times = 0 unless @redirect_times
+			@redirect_times = @redirect_times.succ
+			raise 'too deep redirect...' if @redirect_times > @options[:redirect_limits]
+			request('get', @options)
+		else
+			response
+		end
+	end
+
+  # for ftp
+  def self.ftp(method, options)
+    require 'net/ftp'
+    options = {:close => true}.merge(options)
+    options[:url] = "ftp://#{options[:url]}" unless options[:url] =~ /^ftp:\/\//
+    uri = URI(options[:url])
+    guest_name, guest_pass = 'anonymous', 'guest@' + uri.host
+    unless options[:username]
+      options[:username], options[:password] = uri.userinfo ? uri.userinfo.split(':') : [guest_name, guest_pass]
+    end
+    options[:username] = guest_user unless options[:username]
+    options[:password] = guest_pass unless options[:password]
+    ftp = Net::FTP.open(uri.host, options[:username], options[:password])
+    return ftp unless method
+    stat = case method.to_sym
+           when :get
+             options[:to] = File.basename(uri.path) unless options[:to]
+             ftp.getbinaryfile(uri.path, options[:to])
+           when :put
+             ftp.putbinaryfile(options[:from], uri.path)
+           when :mkdir, :rmdir, :delete, :size, :mtime, :list, :nlst
+             ftp.method(method).call(uri.path)
+           when :rename
+             ftp.rename(uri.path, options[:to]) if options[:to]
+           when :status
+             ftp.status
+           else
+             return ftp
+           end
+    if options[:close]
+      ftp.close
+      stat
+    else
+      ftp.response = stat
+      ftp
+    end
+  end
+
+  # catch all of http requests
+	def self.method_missing(method_name, args)
+		method_name = method_name.to_s.downcase
+		raise NoHttpMethodException, "No such http method can be called: #{method_name}" unless self.http_methods.include?(method_name)
+		self.instance.request(method_name, args)
+	end
+
+	private
+
+  # for upload files by post method
+  def build_multipart
+    require 'md5'
+    boundary = MD5.md5(rand.to_s).to_s[0..5]
+    @headers['Content-type'] = "multipart/form-data, boundary=#{boundary}"
+    multipart = []
+    if @options[:parameters]
+      @options[:parameters] = CGI.parse(@options[:parameters]) if @options[:parameters].is_a? String
+      if @options[:parameters].is_a? Hash
+        @options[:parameters].each {|k, v| 
+          multipart << "--#{boundary}" 
+          multipart << "Content-disposition: form-data; name=\"#{CGI.escape(k.to_s)}\"" 
+          multipart << "\r\n#{CGI.escape(v.to_s)}"
+        }
+      end
+    end
+    @options[:files].each_with_index {|f, index|
+      f[:field_name] ||= "files[]"
+      f[:file_name] ||= "#{boundary}_#{index}"
+      f[:transfer_encoding] ||= "binary"
+      f[:content_type] ||= 'application/octet-stream'
+      multipart << "--#{boundary}" 
+      multipart << "Content-disposition: form-data; name=\"#{f[:field_name]}\"; filename=\"#{f[:file_name]}\""
+      multipart << "Content-type: #{f[:content_type]}"
+      multipart << "Content-Transfer-Encoding: #{f[:transfer_encoding]}"
+      multipart << "\r\n#{f[:file_content]}"
+    }
+    multipart << "--#{boundary}--"
+    multipart = multipart.join("\r\n")
+    @headers['Content-length'] = "#{multipart.size}"
+    @options[:parameters] = multipart
+  end
+
+  # send request
+	def send_request(http)
+		case @options[:method]
+		when /^(get|head|options|delete|move|copy|trace|)$/
+			@options[:parameters] = @uri.query.to_s if @options[:parameters].to_s.empty?
+			@options[:parameters] = "?#{@options[:parameters]}" unless @options[:parameters].empty?
+			http.method(@options[:method]).call("#{@uri.path}#{@options[:parameters]}", @headers)
+		else
+			http.method(@options[:method]).call(@uri.path, @options[:parameters], @headers)
+		end
+	end
+end
+
+# get cookies as hash
+class Net::HTTPResponse
+  def cookies
+    cookies = {}
+    ignored_cookie_names = %w{expires domain path secure httponly}
+    self['set-cookie'].split(/[;,]/).each {|it|
+      next unless it.include? '='
+      eq = it.index('=')
+      key = it[0...eq].strip
+      value = it[eq.succ..-1]
+      next if ignored_cookie_names.include? key.downcase
+      cookies[key] = value
+    }
+    cookies
+  end
+end
+
+# for ftp response
+class Net::FTP
+  def response=(response)
+    @_response = response
+  end
+
+  def response
+    @_response
+  end
+end
+
+# exception
+class NoHttpMethodException < Exception; end
+
+# for command line
+if __FILE__.eql? $0
+	method, url, params = ARGV
+  exit unless method
+	source_method = method
+	method = method.split('_')[0] if method.include? '_'
+
+	# fix path of the url
+	url = "http://#{url}" unless url =~ /^(http:\/\/)/i
+
+	params = if params
+    "{:url => '#{url}', :parameters => '" + params + "'}"
+  else
+    "'#{url}'"
+  end
+
+	if HttpRequest.http_methods.include?(method) && url
+		http = eval("HttpRequest.#{method}(#{params})")
+		case source_method
+		when /_only_header$/
+			http.each{|k,v| puts "#{k}: #{v}"}
+		when /_with_header$/
+			http.each{|k,v| puts "#{k}: #{v}"}
+			print http.body unless http.body.to_s.empty?
+		else
+			print http.body unless http.body.to_s.empty?
+		end
+	end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+name: http_request.rb
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- xianhua.zhou
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-11 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: xianhua.zhou@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Changelog
+- README.rdoc
+- lib/http_request.rb
+has_rdoc: true
+homepage: http://httprequest.rubyforge.org
+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: []
+
+rubyforge_project: http_request.rb
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: http_request.rb is a small, lightweight, powerful HttpRequest class based on the 'net/http' and 'net/ftp' libraries
+test_files: []
+