http-requestor 0.0.4 → 1.0.0

data/README.rdoc

@@ -11,8 +11,8 @@ A Wrapper around Net/HTTP which allows you to perform HTTP Requests in a simple
 
 === Initialize a domain, and send request to multiple paths
 
-  http = HttpRequestor.new("http://www.mydomain.com")
-  # This will initialize the HttpRequestor class
+  http = HTTP::Requestor.new("http://www.mydomain.com")
+  # This will initialize the HTTP::Requestor class
 
   get_request    = http.get(path, parameters, headers)
   post_request   = http.post(path, parameters, headers)
@@ -25,7 +25,7 @@ A Wrapper around Net/HTTP which allows you to perform HTTP Requests in a simple
 
 === Get a response right away  
 
-  HttpRequestor.request(domain, request_type, path, parameters, headers)
+  HTTP::Requestor.request(domain, request_type, path, parameters, headers)
   # domain       => for example: "http://www.some_domain.com"
   # request_type => GET|POST|PUT|DELETE
   # path         => for example: "/some_path"
@@ -34,7 +34,7 @@ A Wrapper around Net/HTTP which allows you to perform HTTP Requests in a simple
   
 OR you can do it the other way
   
-  HttpRequestor.request_with_url(url, request_type, data, headers)
+  HTTP::Requestor.request_with_url(url, request_type, data, headers)
   # url          => for example: "http://www.some_domain.com/some_path_value"
   # request_type => GET|POST|PUT|DELETE
   # parameters   => this is an optional parameter, if you want to send some parameters alongwith the request, you can pass a hash with
@@ -42,11 +42,24 @@ OR you can do it the other way
   
 === HTTP Basic Authentication
 
-  HttpRequestor.send_basic_auth_request(url, username, password)
+  HTTP::Requestor.send_basic_auth_request(url, username, password)
   # url      => for example: "http://www.some_domain.com/some_path_value" only GET URL's supported currently
   # username => basic_auth_username
   # password => basic_auth_password
+
+=== Multipart Form Post
+
+  uri = "http://some_domain/somepath"
+  data = {:file => File.open("testfile.txt")}
+  response = HTTP::Requestor.multipart_request(uri, "post | put", data)
+  
+  # If you already have the instance of HTTP::Requestor class then you can upload files as follows:
   
+  http = HTTP::Requestor.new("http://www.mydomain.com")
+  response = http.post_multipart(some_path, {:file => File.open("testfile.txt")})
+  response = http.put_multipart(some_path, {:file => File.open("testfile.txt")})
+  
+
 == Issues and Suggestions
 
 Please report all the issues in the Github Issues Page, suggestions are also welcome.

data/lib/http_requestor.rb

@@ -0,0 +1,148 @@
+require "net/http"
+require "net/https"
+require "uri"
+
+module HTTP
+  class Requestor
+    #============== Instance Methods ===================
+    def initialize(domain, options={})
+      domain = "http://#{domain}" if domain.match(/^(http|https):\/\//).nil?
+  
+      @defaults = {:domain => domain}
+      @uri = URI.parse(@defaults[:domain])
+      if @uri.scheme == "http"
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+      else
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = true
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+  
+    def get(path,data={},headers=nil)
+      data_to_query(data)
+      if headers == nil
+        response = @http.send_request('GET', path, @defaults[:data])
+      else
+        response = @http.send_request('GET', path, @defaults[:data], headers)
+      end
+      response
+    end
+  
+    def post(path,data={},headers=nil)
+      data_to_query(data)
+      if headers == nil
+        response = @http.send_request('POST', path, @defaults[:data])
+      else
+        response = @http.send_request('POST', path, @defaults[:data], headers)
+      end
+      response
+    end
+  
+    def put(path,data={},headers=nil)
+      data_to_query(data)
+      if headers == nil
+        response = @http.send_request('PUT', path, @defaults[:data])
+      else
+        response = @http.send_request('PUT', path, @defaults[:data], headers)
+      end
+      response
+    end
+    
+    def delete(path,data={},headers=nil)
+      data_to_query(data)
+      if headers == nil
+        response = @http.send_request('DELETE', path, @defaults[:data])
+      else
+        response = @http.send_request('DELETE', path, @defaults[:data], headers)
+      end
+      response
+    end
+    
+    def data_to_query(data)
+      @defaults[:data] = (data.nil? || data.empty?) ? "" : data.to_query
+    end
+  
+    #============== Class Methods ===================
+    def self.request(domain, request_type, request_path, data={}, headers={}, options={})
+      request_type.to_s.upcase!
+      request_type = valid_request_types[0] unless valid_request_types.include?(request_type)
+      req = self.new(domain, options)
+      if request_type == "GET"
+        return req.get(request_path, data, headers)
+      elsif request_type == "POST"
+        return req.post(request_path, data, headers)
+      elsif request_type == "PUT"
+        return req.put(request_path, data, headers)
+      elsif request_type == "DELETE"
+        return req.delete(request_path, data, headers)
+      end
+    end
+    
+    def self.request_with_url(url, request_type, data={}, headers={})
+      uri = URI.parse(url)
+      return self.request("#{uri.scheme}://#{uri.host}:#{uri.port}", request_type, uri.request_uri, data, headers)
+    end
+    
+    def self.send_basic_auth_request(url, username, password)
+      uri = URI.parse(url)
+  
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request.basic_auth(username, password)
+      http.request(request)
+    end
+  
+    def self.valid_request_types
+      ["GET", "POST", "UPDATE", "DELETE"]
+    end
+  end
+end
+
+#================ ActiveSupport Like object#to_query methods =========================
+class Hash
+  def to_query(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end.sort * '&'
+  end
+end
+
+class Array
+  def to_query(key)
+    prefix = "#{key}[]"
+    collect { |value| value.to_query(prefix) }.join '&'
+  end
+end
+
+class String
+  def to_query(key)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+  
+  def to_param
+    to_s
+  end
+end
+
+class Symbol
+  def to_query(key)
+    to_s.to_query(key)
+  end
+
+  def to_param
+    to_s
+  end
+end
+
+class File
+  require 'mime/types'
+  def original_filename
+    path.split("/").last
+  end
+  
+  def content_type
+    MIME::Types.type_for(original_filename).first
+  end
+end

data/lib/http_requestor_multipart.rb

@@ -0,0 +1,95 @@
+module HTTP
+  class Requestor
+    def post_multipart(path="", data={},headers=nil)
+      @uri = URI.parse(@defaults[:domain] + path) unless path.empty?
+      build_data(data)
+      req = Net::HTTP::Post.new(@uri.request_uri)
+      req.initialize_http_header(headers) unless headers.nil?
+      req.body = @post_body
+      req["Content-Type"] = "multipart/form-data; boundary=#{@boundary}"
+      res = @http.request(req)
+      @post_body = ""
+      @boundary = ""
+      res
+    end
+  
+    def put_multipart(path="", data={},headers=nil)
+      @uri = URI.parse(@defaults[:domain] + path) unless path.empty?
+      build_data(data)
+      req = Net::HTTP::Put.new(@uri.request_uri)
+      req.initialize_http_header(headers) unless headers.nil?
+      req.body = @post_body
+      req["Content-Type"] = "multipart/form-data; boundary=#{@boundary}"
+      res = @http.request(req)
+      @post_body = ""
+      @boundary = ""
+      res
+    end
+  
+    def self.multipart_request(domain, request_type, data={}, headers={}, options={})
+      request_type.to_s.upcase!
+      request_type = valid_request_types[0] unless valid_request_types.include?(request_type)
+      req = self.new(domain, options)
+
+      if request_type == "POST"
+        return req.post_multipart("", data, headers)
+      elsif request_type == "PUT"
+        return req.put_multipart("", data, headers)
+      end
+    end
+
+    private
+      def create_boundary
+        chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+        boundary = ""
+        20.times { boundary = boundary + chars.sample }
+        boundary
+      end
+
+      def build_data(data)
+        @boundary = create_boundary
+        @post_body = ""
+
+        create_post_body(data)
+
+        @post_body << "\r\n--#{@boundary}--\r\n"
+      end
+
+      def create_post_body(parameters, datafile="")
+        parameters.each_pair do |key, value|
+          unless value.nil?
+            disposition = datafile.empty? ? key : "#{datafile}[#{key}]"
+            if value.is_a?(File)
+              @post_body << "\r\n--#{@boundary}\r\n"
+              @post_body << "Content-Disposition: form-data; name=\"#{disposition}\"; filename=\"#{value.original_filename}\"\r\n"
+              @post_body << "Content-Type: #{value.content_type}\r\n"
+              @post_body << "\r\n"
+              @post_body << File.read(value)
+            elsif [Hash].include?(value.class)
+              create_post_body(value, disposition)
+            elsif value.is_a?(Array)
+              value.each do |a|
+                if [Hash].include?(a.class)
+                  create_post_body(a, "#{disposition}[]")
+                elsif [File].include?(a.class)
+                  @post_body << "\r\n--#{@boundary}\r\n"
+                  @post_body << "Content-Disposition: form-data; name=\"#{disposition}[]\"; filename=\"#{a.original_filename}\"\r\n"
+                  @post_body << "Content-Type: #{a.content_type}\r\n"
+                  @post_body << "\r\n"
+                  @post_body << File.read(a)
+                else
+                  @post_body << "\r\n--#{@boundary}\r\n"
+                  @post_body << "Content-Disposition: form-data; name=\"#{disposition}[]\"\r\n\r\n"
+                  @post_body << "#{a}"
+                end
+              end
+            else
+              @post_body << "\r\n--#{@boundary}\r\n"
+              @post_body << "Content-Disposition: form-data; name=\"#{disposition}\"\r\n\r\n"
+              @post_body << "#{value}"
+            end
+          end
+        end
+      end
+  end
+end

data/test/http_requestor_test.rb

@@ -1,22 +1,44 @@
-require "../lib/http-requestor"
+require "../lib/http_requestor"
+require "../lib/http_requestor_multipart"
 require "test/unit"
  
 class HttpRequestorTest < Test::Unit::TestCase
- 
-  def test_should_raise_error_for_invalid_url_scheme
-    assert_raise(InvalidURISchemeException) { HttpRequestor.new("some://www.invalid_url_scheme.com") }
+  def test_should_get_data_when_request_type_not_specified
+    assert_equal("200", HTTP::Requestor.request("http://en.wikibooks.org", "", "/wiki/Ruby_Programming/Unit_testing#A_Simple_Introduction").code )
   end
   
-  def test_should_not_raise_error_for_valid_url_scheme
-    assert_nothing_raised(InvalidURISchemeException) { HttpRequestor.new("http://www.google.com") }
-    assert_nothing_raised(InvalidURISchemeException) { HttpRequestor.new("https://www.yahoo.com") }
+  def test_should_post_file_properly
+    headers = {"application_api_key" => "bltc5b185cd6884ae87", "application_uid" => "blt2f37284c14b6b453"}
+    uri = "http://localhost:3000/files.json"
+    f=File.open("testfile.txt", "w+")
+    f.syswrite("This is testing")
+    f.close
+    data = {:object => {:title => "This is from http-requestor", :file1 => File.open("testfile.txt")}}
+
+    assert_equal("201", HTTP::Requestor.multipart_request(uri, "post", data, headers).code)
   end
+  
+  def test_should_post_file_properly_with_instance_method_used
+    http = HTTP::Requestor.new("http://localhost:3000")
+    
+    headers = {"application_api_key" => "bltc5b185cd6884ae87", "application_uid" => "blt2f37284c14b6b453"}
+    path = "/files.json"
+    f=File.open("testfile.txt", "w+")
+    f.syswrite("This is testing")
+    f.close
+    data = {:object => {:title => "This is from http-requestor", :file1 => File.open("testfile.txt")}}
 
-  def test_should_raise_error_on_invalid_request_type
-    assert_raise(InvalidRequestTypeException) { HttpRequestor.request("http://en.wikibooks.org", "OPTIONS", "/wiki/Ruby_Programming/Unit_testing#A_Simple_Introduction") }
+    assert_equal("201", http.post_multipart(path, data, headers).code)
   end
   
-  def test_should_not_raise_error_on_valid_request_type
-    assert_nothing_raised(InvalidRequestTypeException) { HttpRequestor.request("http://en.wikibooks.org", "GET", "/wiki/Ruby_Programming/Unit_testing#A_Simple_Introduction") }
+  def test_should_post_multiple_files
+    headers = {"application_api_key" => "bltc5b185cd6884ae87", "application_uid" => "blt2f37284c14b6b453"}
+    uri = "http://localhost:3000/multiplefiles.json"
+    f=File.open("testfile.txt", "w+")
+    f.syswrite("This is testing")
+    f.close
+    data = {:object => {:title => ["Title 1", "Title 2"], :file => [File.open("testfile.txt"), File.open("testfile.txt")]}}
+
+    assert_equal("201", HTTP::Requestor.multipart_request(uri, "post", data, headers).code)
   end
 end

data/test/testfile.txt

@@ -0,0 +1 @@
+This is testing

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http-requestor
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,20 +9,35 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000Z
-dependencies: []
-description: A Wrapper around Net/HTTP which allows you to perform HTTP Requests.
+date: 2012-11-23 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: &28629120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.17.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *28629120
+description: ! "    A Wrapper around Net/HTTP which allows you to perform HTTP Requests.\n
+  \   Gives you a simple API interface to send multipart requests.\n"
 email: rohit0981989@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/http-requestor.rb
+- lib/http_requestor.rb
+- lib/http_requestor_multipart.rb
 - MIT-LICENSE
 - README.rdoc
 - test/http_requestor_test.rb
+- test/testfile.txt
 homepage: http://github.com/rohit9889/http-requestor
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -41,9 +56,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: A Wrapper around Net/HTTP which allows you to perform HTTP Requests.
 test_files:
 - test/http_requestor_test.rb
+- test/testfile.txt

data/lib/http-requestor.rb

@@ -1,134 +0,0 @@
-require "net/http"
-require "net/https"
-require "uri"
-
-class HttpRequestor
-
-  #============== Instance Methods ===================
-  
-  def initialize(domain, options={})
-    raise InvalidURISchemeException, "Please send a valid URI scheme." if domain.match(/(http|https):\/\//).nil?
-
-    @defaults = {:domain => domain}
-    uri = URI.parse(@defaults[:domain])
-    if uri.scheme == "http"
-      @http = Net::HTTP.new(uri.host, uri.port)
-    else
-      @http = Net::HTTP.new(uri.host, uri.port)
-      @http.use_ssl = true
-      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    end
-  end
-
-  def get(path,data={},headers=nil)
-    data = data_to_query(data)
-    if headers == nil
-      response = @http.send_request('GET',path,data)
-    else
-      response = @http.send_request('GET',path,data,headers)
-    end
-    response
-  end
-
-  def post(path,data={},headers=nil)
-    data = data_to_query(data)
-    if headers == nil
-      response = @http.send_request('POST',path,data)
-    else
-      response = @http.send_request('POST',path,data,headers)
-    end
-    response
-  end
-
-  def put(path,data={},headers=nil)
-    data = data_to_query(data)
-    if headers == nil
-      response = @http.send_request('PUT',path,data)
-    else
-      response = @http.send_request('PUT',path,data,headers)
-    end
-    response
-  end
-  
-  def delete(path,data={},headers=nil)
-    data = data_to_query(data)
-    if headers == nil
-      response = @http.send_request('DELETE',path,data)
-    else
-      response = @http.send_request('DELETE',path,data,headers)
-    end
-    response
-  end
-  
-  def data_to_query(data)
-    return (data.nil? || data.empty?) ? "" : data.to_query
-  end
-
-  #============== Class Methods ===================
-  def self.request(domain, request_type, request_path, data={}, headers={})
-    request_type.upcase!
-    raise InvalidRequestTypeException, "Please pass a valid request type." unless valid_request_types.include?(request_type)
-    req = HttpRequestor.new(domain)
-    if request_type == "GET"
-      return req.get(request_path, data, headers)
-    elsif request_type == "POST"
-      return req.post(request_path, data, headers)
-    elsif request_type == "PUT"
-      return req.put(request_path, data, headers)
-    elsif request_type == "DELETE"
-      return req.delete(request_path, data, headers)
-    end
-  end
-  
-  def self.request_with_url(url, request_type, data={}, headers={})
-    uri = URI.parse(url)
-    return self.request("#{uri.scheme}://#{uri.host}:#{uri.port}", request_type, uri.request_uri, data, headers)
-  end
-  
-  def self.send_basic_auth_request(url, username, password)
-    uri = URI.parse(url)
-
-    http = Net::HTTP.new(uri.host, uri.port)
-    request = Net::HTTP::Get.new(uri.request_uri)
-    request.basic_auth(username, password)
-    http.request(request)
-  end
-
-  def self.valid_request_types
-    ["GET", "POST", "UPDATE", "DELETE"]
-  end
-end
-
-#================ ActiveSupport Like object#to_query methods =========================
-class Hash
-  def to_query(namespace = nil)
-    collect do |key, value|
-      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-    end.sort * '&'
-  end
-end
-
-class Array
-  def to_query(key)
-    prefix = "#{key}[]"
-    collect { |value| value.to_query(prefix) }.join '&'
-  end
-end
-
-class String
-  def to_query(key)
-    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
-    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
-  end
-  
-  def to_param
-    to_s
-  end
-end
-
-#================= Exceptions ======================
-class InvalidRequestTypeException < Exception
-end
-
-class InvalidURISchemeException < Exception
-end