http_wrapper 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 425cf2e9d257f1b5fa7740175a8f73cb016c3a30
-  data.tar.gz: ac5befa4cc51dd8ea3370a6ab86bbcb145c37a54
+  metadata.gz: a2fa8e4065e61bf929e24793f65c42273fa98884
+  data.tar.gz: 4e0efea520c0a5cca574430e3d8cef060004cd60
 SHA512:
-  metadata.gz: 5d7ea56a231b668b36017f6f0b12aeab2c76ad83fad1618e6e25736f394445c6537cef1f19d96611408bec41acff5883189308dd93477cd5322e40e9bf6519b2
-  data.tar.gz: 9b5d9c375e60c37f658a33b54eb4ef4cec6892ce50e36e5399c93bcf7d397f2f3f536e192c2e9189ce35be7ecc0984c6b866c21b65e2815426756c9abbfacbd3
+  metadata.gz: 380fa0e02f48cb4affca5d9c74fe54352965bbd6b4630909f509ffddced19f49af661595fce73aa6387e811989ea769d0f93a5ceb31855a60600b0f15b4b7180
+  data.tar.gz: 833ada0ed80bd08c7d6313f6e2c07bdc4c9cdb3ee976aac359d8f44420756cbdb45bb2216e09ce8e128351fbbf687ddd625d29315f759fb561803253b3933f27

data/CHANGELOG.md

@@ -1,5 +1,100 @@
 # Changelog
 
+## v2.1.0
+
+* added ability to perform custom `Net::HTTP` requests
+
+    ```ruby
+    http = HTTPWrapper.new
+    uri = URI 'http://example.com'
+
+    # Ruby v2.0.0
+    request = Net::HTTP::Head.new uri
+    # Ruby v1.9.3
+    request = Net::HTTP::Head.new uri.request_uri
+
+    http.execute request, uri
+    ```
+
+* added ability to upload files with `multipart/form-data` content type
+
+    ```ruby
+    http = HTTPWrapper.new
+    params = {
+      multipart: [
+        # ['file input field name', 'File instance or string', {filename: 'itsfile.jpg', content_type: '...'}]
+        # last element is optional
+        ['user_pic', File.open('user_pic.jpg')],
+        ['user_photo', File.read('user_photo.jpg'), {filename: 'photo.jpg'}],
+        # you can also specify other parameters
+        ['user_name', 'john griffin']
+      ],
+      # or you can specify other parameters in body section
+      # it will be merged with multipart data
+      body: {
+        user_age: 25
+      }
+    }
+    response = http.post some_url, params
+    ```
+
+* fixed incorrect content type for `DELETE` request
+* default content type changed to `text/html`
+* added `:user_agent` and `:content_type` shortcuts
+
+    ```ruby
+    # you can specify now user agent like so:
+    http = HTTWrapper.new user_agent: 'custom user agent'
+    # - or -
+    http.user_agent = 'custom user agent'
+    http.get sample_url
+    # - or -
+    http.get sample_url, user_agent: 'custom user agent'
+    ```
+
+    ```ruby
+    # you can specify now content type like so:
+    http.get sample_url, content_type: 'text/html'
+    ```
+
+* added ability to specify headers as symbols
+
+    ```ruby
+    http.get some_url, headers: {x_requested_with: 'XMLHttpRequest'}
+    # - the same as -
+    http.get some_url, headers: {'X-Requested-With' => 'XMLHttpRequest'}
+    ```
+
+* added ability to fix urls without scheme with default http scheme
+
+    ```ruby
+    http.get 'example.com'
+    # will correctly request http://example.com
+    ```
+
+* added `:max_redirects` option to specify redirect following limits
+* added `:logger` option
+
+    ```ruby
+    log = Logger.new
+    http = HTTPWrapper.new logger: log
+    - or -
+    http.logger = $stdout
+    ```
+
+* massive refactoring
+* `:ca_file` option removed
+* `:validate_ssl_cert` option renamed to `:verify_cert`
+* `soap` methods removed due to rare usage
+* `:method` key removed from params
+* `:params` key changed to `:query`
+
+    ```ruby
+    http.get some_url, query: { user_id: 1, text: 'abcdefg' }
+    ```
+
+* fixed bug with timeout - it should be set in seconds, not microseconds
+
 ## v2.0.0
 
 * Gem rewritten completely and renamed to 'http_wrapper'

data/Gemfile

@@ -1,3 +1,2 @@
 source 'https://rubygems.org'
-
 gemspec

data/README.md

@@ -1,12 +1,22 @@
 # http_wrapper
 
-Simple wrapper around standard Net::HTTP library to simplify common http[s] tasks usage
+Simple wrapper around standard Net::HTTP library
+
+[![Gem Version](https://badge.fury.io/rb/http_wrapper.png)](http://badge.fury.io/rb/http_wrapper)
+[![Build Status](https://travis-ci.org/Svyatov/http_wrapper.png)](https://travis-ci.org/Svyatov/http_wrapper)
+[![Dependency Status](https://gemnasium.com/Svyatov/http_wrapper.png)](https://gemnasium.com/Svyatov/http_wrapper)
+[![Code Climate](https://codeclimate.com/github/Svyatov/http_wrapper.png)](https://codeclimate.com/github/Svyatov/http_wrapper)
+[![Coverage Status](https://coveralls.io/repos/Svyatov/http_wrapper/badge.png)](https://coveralls.io/r/Svyatov/http_wrapper)
+
+---
 
 ## Installation
 
 Add this line to your Gemfile:
 
-    gem 'http_wrapper', '~> 2.0.0'
+```ruby
+gem 'http_wrapper', '~> 2.1.0'
+```
 
 And then execute:
 
@@ -32,12 +42,26 @@ http = HTTPWrapper.new
 
 ### Access unprotected resource located at **some_url**:
 
-Resource is redirecting? No problem! `http_wrapper` follows up to 10 sequential redirects (you cannot change that limit yet).
+```ruby
+response = http.get some_url
+
+# response is always an instance of Net::HTTPResponse
+```
+
+Resource is redirecting? No problem! `http_wrapper` follows up to 10 sequential redirects by default.
+But you can specify your own limits.
 
 ```ruby
+http.max_redirects = 5
 response = http.get some_url
 ```
 
+Url doesn't have scheme? `http_wrapper` prefixes url with `http://` if scheme is missing.
+
+```ruby
+http.get 'example.com' # will correctly request 'http://example.com'
+```
+
 ### Access resource protected by form-based authentication:
 
 1. Post your credentials and get authentication cookie
@@ -48,7 +72,7 @@ response = http.get some_url
     # credentials as body params
     cookie = http.post_and_get_cookie some_url, body: { username: 'iamjohn', password: '$uperS1kret' }
     # - or - credentials as GET query params
-    cookie = http.post_and_get_cookie some_url, params: { username: 'iamjohn', password: '$uperS1kret' }
+    cookie = http.post_and_get_cookie some_url, query: { username: 'iamjohn', password: '$uperS1kret' }
     ```
 
 2. Get protected resource with provided cookie
@@ -69,19 +93,11 @@ response = http.get 'http://example.com', auth: { login: 'iamjohn', password: 'i
 Add special header or use special method:
 
 ```ruby
-response = http.get some_url, headers: {'X-Requested-With' => 'XMLHttpRequest'}
-# - or -
 response = http.get_ajax some_url
-```
-
-### Access SOAP resource
-
-Same as before, add special header or use special method:
-
-```ruby
-response = http.get some_url, headers: {'SOAPAction' => 'someSoapOperation', 'Content-Type' => 'text/xml; charset=UTF-8'}
 # - or -
-response = http.get_soap some_url
+response = http.get some_url, headers: {x_requested_with: 'XMLHttpRequest'}
+# - or -
+response = http.get some_url, headers: {'X-Requested-With' => 'XMLHttpRequest'}
 ```
 
 ### Access JSON resource
@@ -89,9 +105,13 @@ response = http.get_soap some_url
 Same as before :)
 
 ```ruby
-response = http.get some_url, headers: {'Content-Type' => 'application/json; charset=UTF-8'}
-# - or -
 response = http.get_json some_url
+# - or -
+response = http.get some_url, content_type: 'application/json; charset=UTF-8'
+# - or -
+response = http.get some_url, headers: {content_type: 'application/json; charset=UTF-8'}
+# - or -
+response = http.get some_url, headers: {'Content-Type' => 'application/json; charset=UTF-8'}
 ```
 
 ### Access JSON resource mimicing AJAX
@@ -115,34 +135,73 @@ response = http.get_json_ajax some_url, some_params
 Don't worry about escaping, `http_wrapper` got you covered here either.
 
 ```ruby
-response = http.get 'http://www.google.com', params: {message: 'Hi! M&Ms!', user: 'iamjohn'}
+response = http.get 'http://www.google.com', query: {message: 'Hi! M&Ms!', user: 'iamjohn'}
 # => http://www.google.com/?message=Hi!%20M%26Ms!&user=iamjohn
 ```
 
 Don't worry about parameters that already in URL, they'll be merged.
 
 ```ruby
-response = http.get 'http://www.google.com/?q=test', params: {user: 'iamjohn'}
+response = http.get 'http://www.google.com/?q=test', query: {user: 'iamjohn'}
 # => http://www.google.com/?q=test&user=iamjohn
 ```
 
-### Set timeout for wrapper:
+### Files upload
+
+You can easily upload any number of files with `multipart/form-data` content type.
+
+```ruby
+http = HTTPWrapper.new
+params = {
+  multipart: [
+    # ['file input field name', 'File instance or string', {filename: 'itsfile.jpg', content_type: '...'}]
+    ['user_photo', File.read('user_photo.jpg'), {filename: 'photo.jpg'}],
+    # last element is optional
+    ['user_pic', File.open('user_pic.jpg')],
+    # you can also specify other parameters
+    ['user_name', 'john griffin']
+  ],
+  # or you can specify other parameters in body section
+  # it will be merged with multipart data
+  body: {
+    user_age: 25
+  }
+}
+response = http.post some_url, params
+```
+
+### Set timeout
+
+By default timeout is set to 10 seconds.
 
 ```ruby
-http.timeout = 10000 # in milliseconds
+http.timeout = 5 # in seconds
 # - or - on instantiation
-http = HTTPWrapper.new timeout: 10000
+http = HTTPWrapper.new timeout: 5
+```
+
+### Set logger
+
+If you need to debug your requests, it's as simple as to say to `http_wrapper` where to output debug information.
+
+```ruby
+logger = Logger.new '/path/to/log_file'
+http.logger = logger
+# - or -
+http = HTTPWrapper.new logger: $stdout
+# - to switch logger off -
+http.logger = nil
 ```
 
 ### Work over SSL
 
-To work over SSL enable certificate validation before any calls:
+`http_wrapper` works with SSL out of the box and by default verifying domain SSL certificate.
+But you can easily turn verification off if needed.
 
 ```ruby
-http.validate_ssl_cert = true
-http.ca_file = '/path/to/your/ca_file'
+http.verify_cert = false
 # - or - on instantiation
-http = HTTPWrapper.new ca_file: '/path/to/your/ca_file', validate_ssl_cert: true
+http = HTTPWrapper.new verify_cert: false
 ```
 
 ### POST, PUT and DELETE requests
@@ -154,7 +213,7 @@ http.post some_url, body: {user: 'iamjohn', password: 'secret'}
 # - or -
 http.put some_url, body: {user: 'iamjohn', password: 'secret'}
 # - or -
-http.delete some_url, params: {user: 'iamjohn'}
+http.delete some_url, query: {user: 'iamjohn'}
 ```
 
 Default content type header for these requests is `application/x-www-form-urlencoded; charset=UTF-8`.
@@ -167,6 +226,33 @@ For `get_json` there are `post_json`, `put_json` and `delete_json`.
 
 And for `get_ajax_json`, there are `post_ajax_json`, `put_ajax_json` and `delete_ajax_json`.
 
+### Change User Agent
+
+```ruby
+http = HTTWrapper.new user_agent: 'custom user agent'
+# - or -
+http.user_agent = 'custom user agent'
+http.get sample_url
+# - or -
+http.get sample_url, user_agent: 'custom user agent'
+# - or -
+http.get sample_url, headers: { user_agent: 'custom user agent' }
+# the last one always replaces other definitions
+```
+
+### Perform own custom Net::HTTP requests
+
+```ruby
+uri = URI 'http://example.com'
+
+# Ruby 2.0.0
+request = Net::HTTP::Head.new uri
+# Ruby 1.9.3
+request = Net::HTTP::Head.new uri.request_uri
+
+http.execute request, uri
+```
+
 ### Full params hash example
 
 ```ruby
@@ -175,11 +261,15 @@ And for `get_ajax_json`, there are `post_ajax_json`, `put_ajax_json` and `delete
   headers: {
     'Content-Type' => 'text/html',
     'X-Requested-With' => 'XMLHttpRequest',
-    'User-Agent' => 'Chrome v123'
+    'User-Agent' => 'Chrome v123',
+    # - or - use symbols
+    content_type: 'text/xml',
+    x_requested_with: 'XMLHttpRequest',
+    user_agent: 'Chrome v123'
   },
 
   # Query Parameters
-  params: {
+  query: {
     user: 'iamjohn',
     'user-stuff' => '123abc'
   },
@@ -200,13 +290,29 @@ And for `get_ajax_json`, there are `post_ajax_json`, `put_ajax_json` and `delete
     as: 'a hash'
   },
 
-  # Request method - :get, :post, :put, :delete
-  :method => :get
+  # Shortcut for User-Agent header (headers hash takes precedence)
+  user_agent: 'UserAgent v1.2.3',
+
+  # Shortcut for Content-Type header (headers hash takes precedence)
+  content_type: 'text/xml',
+
+  # multipart/form-data for file uploads
+  # the format of array of arrays is important here!
+  multipart: [
+    # you can use File object
+    ['file_input_name', File.open('somefile.ext')],
+    # - or - string and specify filename
+    ['file_input_name', File.read('somefile.ext'), {filename: 'readme.txt'}],
+    # - or - full format
+    ['file_input_name', 'some file content', {filename: 'readme.txt', content_type: 'text/text'}],
+    # - or - add other simple parameters
+    ['user_name', 'john smith']
+  ]
 }
 ```
 
-Don't worry if you mistype root parameters key. `http_wrapper` checks root params keys and instantiation options keys.
-If any unknown options or parameters found, they raise the `UnknownParameterError` exception.
+Don't worry if you mistype root parameters key. `http_wrapper` checks root parameters keys and instantiation options keys.
+If any unknown options or parameters found, it raises the `UnknownParameterError` exception.
 
 ## Contributing
 

data/Rakefile

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift File.expand_path('lib', File.dirname(__FILE__))
 
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 task :default => :spec

data/lib/http_wrapper/constants.rb

@@ -1,16 +1,20 @@
 class HTTPWrapper
-  KNOWN_OPTIONS_KEYS   = [:timeout, :ca_file, :validate_ssl_cert].freeze
-  KNOWN_PARAMS_KEYS    = [:headers, :params, :cookie, :auth, :body, :method].freeze
+  module HEADER
+    CONTENT_TYPE = 'Content-Type'.freeze
+    USER_AGENT   = 'User-Agent'.freeze
+    COOKIE       = 'Cookie'.freeze
+    AJAX         = 'X-Requested-With'.freeze
+  end
 
-  HEADER_CONTENT_TYPE  = 'Content-Type'.freeze
+  module CONTENT_TYPE
+    DEFAULT   = 'text/html; charset=UTF-8'.freeze
+    JSON      = 'application/json; charset=UTF-8'.freeze
+    POST      = 'application/x-www-form-urlencoded'.freeze
+    MULTIPART = 'multipart/form-data'.freeze
+  end
 
-  DEFAULT_CONTENT_TYPE = 'text/xml; charset=UTF-8'.freeze
-  JSON_CONTENT_TYPE    = 'application/json; charset=UTF-8'.freeze
-  POST_CONTENT_TYPE    = 'application/x-www-form-urlencoded; charset=UTF-8'.freeze
-
-  HEADER_USER_AGENT    = 'User-Agent'.freeze
-  HEADER_COOKIE        = 'Cookie'.freeze
-
-  HEADER_AJAX          = 'X-Requested-With'.freeze
-  HEADER_AJAX_VALUE    = 'XMLHttpRequest'.freeze
+  USER_AGENT  = "HTTPWrapper/#{HTTPWrapper::VERSION}; Ruby/#{RUBY_VERSION}".freeze
+  AJAX_HEADER = { HEADER::AJAX => 'XMLHttpRequest'.freeze }.freeze
+  JSON_HEADER = { HEADER::CONTENT_TYPE => CONTENT_TYPE::JSON }.freeze
+  AJAX_JSON_HEADER = AJAX_HEADER.dup.merge!(JSON_HEADER).freeze
 end

data/lib/http_wrapper/http_wrapper.rb

@@ -1,97 +1,35 @@
-require 'uri/common'
 require 'net/https'
-require_relative 'constants'
-require_relative 'errors'
-require_relative 'version'
 
 class HTTPWrapper
-  attr_accessor :timeout, :ca_file, :validate_ssl_cert
+  KNOWN_OPTIONS_KEYS = [:timeout, :verify_cert, :logger, :max_redirects, :user_agent].freeze
 
-  def initialize(options = {})
-    unknown_options = options.keys - KNOWN_OPTIONS_KEYS
-
-    if unknown_options.length > 0
-      raise UnknownParameterError.new "Unknown options: #{unknown_options.join(', ')}"
-    end
-
-    @timeout           = options.fetch(:timeout) { 10000 }
-    @ca_file           = options.fetch(:ca_file) { nil }
-    @validate_ssl_cert = options.fetch(:validate_ssl_cert) { false }
-  end
+  attr_accessor :timeout, :verify_cert, :logger, :max_redirects, :user_agent
 
-  def self.default_user_agent
-    "HTTPWrapper/#{VERSION}; Ruby/#{RUBY_VERSION}"
-  end
+  def initialize(options = {})
+    validate_options options
 
-  def get(url, params = {})
-    params = validate_parameters_and_init_headers params
-    locate_response url, params
+    @timeout       = options.fetch(:timeout) { 10 }
+    @verify_cert   = options.fetch(:verify_cert) { true }
+    @logger        = options.fetch(:logger) { nil }
+    @max_redirects = options.fetch(:max_redirects) { 10 }
+    @user_agent    = options.fetch(:user_agent) { USER_AGENT }
   end
 
-  [:post, :put, :delete].each do |method|
+  [:get, :post, :put, :delete].each do |method|
     define_method method do |url, params = {}|
-      params = validate_parameters_and_init_headers params
-      params[:headers][HEADER_CONTENT_TYPE] ||= POST_CONTENT_TYPE
-      params[:method] = method
-      locate_response url, params
-    end
-  end
-
-  def get_soap(url, params = {})
-    params = validate_parameters_and_init_headers params
-    params[:headers]['SOAPAction'] ||= ''
-    params[:headers][HEADER_CONTENT_TYPE] ||= DEFAULT_CONTENT_TYPE
-    locate_response url, params
-  end
-
-  [:post, :put, :delete].each do |method|
-    define_method "#{method.to_s}_soap" do |url, params = {}|
-      params[:method] = method
-      get_soap url, params
+      params[:user_agent] ||= @user_agent
+      get_response Request.new(url, method, params)
     end
-  end
-
-  def get_ajax(url, params = {})
-    params = validate_parameters_and_init_headers params
-    params[:headers][HEADER_AJAX] = HEADER_AJAX_VALUE
-    locate_response url, params
-  end
-
-  [:post, :put, :delete].each do |method|
-    define_method "#{method.to_s}_ajax" do |url, params = {}|
-      params[:method] = method
-      get_ajax url, params
-    end
-  end
-
-  def get_json(url, params = {})
-    params = validate_parameters_and_init_headers params
-    params[:headers][HEADER_CONTENT_TYPE] = JSON_CONTENT_TYPE
-    locate_response url, params
-  end
 
-  [:post, :put, :delete].each do |method|
-    define_method "#{method.to_s}_json" do |url, params = {}|
-      params[:method] = method
-      get_json url, params
-    end
-  end
-
-  def get_ajax_json(url, params = {})
-    params = validate_parameters_and_init_headers params
-    params[:headers][HEADER_CONTENT_TYPE] = JSON_CONTENT_TYPE
-    get_ajax url, params
-  end
-
-  [:post, :put, :delete].each do |method|
-    define_method "#{method.to_s}_ajax_json" do |url, params = {}|
-      params[:method] = method
-      get_ajax_json url, params
+    %w(ajax json ajax_json).each do |header|
+      define_method "#{method.to_s}_#{header}" do |url, params = {}|
+        params[:headers] ||= {}
+        params[:headers].merge! HTTPWrapper.const_get("#{header}_HEADER".upcase)
+        __send__ method, url, params
+      end
     end
-  end
 
-  %w(get post put delete).each do |method|
-    alias_method "#{method}_json_ajax", "#{method}_ajax_json"
+    alias_method "#{method.to_s}_json_ajax", "#{method.to_s}_ajax_json"
   end
 
   def post_and_get_cookie(url, params = {})
@@ -99,103 +37,45 @@ class HTTPWrapper
     response.response['set-cookie']
   end
 
+  def execute(request, uri)
+    connection = create_connection uri
+    connection.request request
+  end
+
   private
 
-  def validate_parameters_and_init_headers(params)
-    params[:headers] ||= {}
-    unknown_params = params.keys - KNOWN_PARAMS_KEYS
+  def validate_options(options)
+    unknown_options = options.keys - KNOWN_OPTIONS_KEYS
 
-    if unknown_params.length > 0
-      raise UnknownParameterError.new "Unknown parameters: #{unknown_params.join(', ')}"
+    if unknown_options.length > 0
+      raise UnknownParameterError.new "Unknown options: #{unknown_options.join(', ')}"
     end
-
-    params
   end
 
-  def locate_response(url, params, redirects_limit = 10)
+  def get_response(request, redirects_limit = @max_redirects)
     raise TooManyRedirectsError.new 'Too many redirects!' if redirects_limit == 0
 
-    response = execute_request url, params
+    response = execute request.create, request.uri
 
     if response.kind_of? Net::HTTPRedirection
-      response = locate_response response['location'], params, redirects_limit - 1
+      request.uri = response['location']
+      response = get_response request, redirects_limit - 1
     end
 
     response
   end
 
-  def execute_request(url, params)
-    params[:headers] ||= {}
-    params[:headers][HEADER_USER_AGENT]   ||= self.class.default_user_agent
-    params[:headers][HEADER_CONTENT_TYPE] ||= DEFAULT_CONTENT_TYPE
-    params[:headers][HEADER_COOKIE] = params[:cookie] if params[:cookie]
-
-    uri = build_uri url, params[:params]
-    connection = create_connection uri
-    request = create_request uri, params
-
-    Timeout.timeout(timeout) do
-      connection.request(request)
-    end
-  end
-
-  def build_uri(url, query_params)
-    uri = URI url
-
-    if query_params
-      if uri.query && !uri.query.empty?
-        new_query = Hash[URI.decode_www_form(uri.query)].merge(query_params)
-      else
-        new_query = query_params
-      end
-      uri.query = URI.encode_www_form new_query
-    end
-
-    uri
-  end
-
   def create_connection(uri)
     connection = Net::HTTP.new uri.host, uri.port
-    connection.read_timeout = timeout
-    connection.open_timeout = timeout
+    connection.read_timeout = @timeout
+    connection.open_timeout = @timeout
 
-    if uri.scheme == 'https'
+    if uri.kind_of? URI::HTTPS
       connection.use_ssl = true
-
-      if validate_ssl_cert
-        connection.ca_file = ca_file
-        connection.verify_mode = OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
-      else
-        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
+      connection.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @verify_cert
     end
 
+    connection.set_debug_output(@logger)
     connection
   end
-
-  def create_request(uri, params)
-    case params[:method]
-      when :get
-        request = Net::HTTP::Get.new    uri.request_uri, params[:headers]
-      when :post
-        request = Net::HTTP::Post.new   uri.request_uri, params[:headers]
-      when :put
-        request = Net::HTTP::Put.new    uri.request_uri, params[:headers]
-      when :delete
-        request = Net::HTTP::Delete.new uri.request_uri, params[:headers]
-      else
-        request = Net::HTTP::Get.new    uri.request_uri, params[:headers]
-    end
-
-    if [:post, :put, :delete].include? params[:method]
-      request.body = params[:body] if params[:body].kind_of? String
-      request.set_form_data(params[:body]) if params[:body].kind_of? Hash
-    end
-
-    if params[:auth]
-      request.basic_auth params[:auth].fetch(:login), params[:auth].fetch(:password)
-    end
-
-    request
-  end
 end

data/lib/http_wrapper/request.rb

@@ -0,0 +1,121 @@
+require 'uri/common'
+
+class HTTPWrapper
+  class Request
+    KNOWN_PARAMS_KEYS = [:headers, :query, :cookie, :auth, :body, :user_agent, :content_type, :multipart].freeze
+
+    def initialize(url, method, params = {})
+      validate_parameters params
+
+      self.uri  = url
+
+      @headers  = params[:headers] || {}
+      @query    = params[:query]   || {}
+      @cookie   = params[:cookie]  || @headers[HEADER::COOKIE]
+      @login    = params[:auth] && params[:auth].fetch(:login)
+      @password = params[:auth] && params[:auth].fetch(:password)
+
+      @method       = method
+      @method_class = Net::HTTP.const_get(method.to_s.capitalize)
+
+      @body         = params[:body]
+      @user_agent   = params[:user_agent]
+      @content_type = params[:content_type]
+
+      @multipart_data = params[:multipart] || []
+
+      initialize_headers
+    end
+
+    attr_reader :uri
+
+    def uri=(url)
+      if url.is_a? URI
+        @uri = url
+      else
+        url = "http://#{url}" unless url =~ /\Ahttps?:\/\//
+        @uri = URI.parse url
+      end
+    end
+
+    def create
+      rebuild_uri_query_params
+      convert_symbol_headers_to_string
+      create_http_request
+    end
+
+    private
+
+    def validate_parameters(params)
+      unknown_params = params.keys - KNOWN_PARAMS_KEYS
+
+      if unknown_params.length > 0
+        raise UnknownParameterError.new "Unknown parameters: #{unknown_params.join(', ')}"
+      end
+    end
+
+    def initialize_headers
+      @headers[HEADER::USER_AGENT] ||= @user_agent
+      case @method
+        when :post, :put then @headers[HEADER::CONTENT_TYPE] ||= (@content_type || CONTENT_TYPE::POST)
+        else @headers[HEADER::CONTENT_TYPE] ||= (@content_type || CONTENT_TYPE::DEFAULT)
+      end
+    end
+
+    def rebuild_uri_query_params
+      return unless @query.size > 0
+      query = @uri.query ? query_to_hash(@uri.query).merge(@query) : @query
+      @uri.query = URI.encode_www_form query
+    end
+
+    def convert_symbol_headers_to_string
+      @headers.keys.select{|key| key.is_a? Symbol}.each do |key|
+        str_key = key.to_s.gsub(/_/, '-').capitalize
+        @headers[str_key] = @headers.delete key
+      end
+    end
+
+    def create_http_request
+      # Ruby v1.9.3 doesn't understand full URI object, it needs just path :(
+      uri = RUBY_VERSION =~ /\A2/ ? @uri : @uri.request_uri
+      @request = @method_class.new uri, @headers
+      set_cookies
+      set_body
+      set_basic_auth
+      @request
+    end
+
+    def set_body
+      return unless @request.request_body_permitted?
+      if @multipart_data.length > 0
+        convert_body_to_multipart_data if @body
+        @request.set_form @multipart_data, CONTENT_TYPE::MULTIPART
+      elsif @body
+        @request.body = @body.is_a?(Hash) ? hash_to_query(@body) : @body
+      end
+    end
+
+    def set_basic_auth
+      return unless @login
+      @request.basic_auth @login, @password
+    end
+
+    def set_cookies
+      return unless @cookie
+      @request['Cookie'] = @cookie
+    end
+
+    def convert_body_to_multipart_data
+      @body = query_to_hash(@body) unless @body.kind_of? Hash
+      @body.each{|key, value| @multipart_data << [key.to_s, value.to_s]}
+    end
+
+    def query_to_hash(query)
+      Hash[URI.decode_www_form query]
+    end
+
+    def hash_to_query(hash)
+      URI.encode_www_form hash
+    end
+  end
+end

data/lib/http_wrapper/version.rb

@@ -1,3 +1,3 @@
 class HTTPWrapper
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.1.0'.freeze
 end

data/lib/http_wrapper.rb

@@ -1 +1,5 @@
+require 'http_wrapper/version'
+require 'http_wrapper/constants'
+require 'http_wrapper/errors'
+require 'http_wrapper/request'
 require 'http_wrapper/http_wrapper'

data/spec/http_wrapper_spec.rb

@@ -8,7 +8,6 @@ describe HTTPWrapper do
 
   it 'should define all dynamic methods' do
     [:get,           :post,           :put,           :delete,
-     :get_soap,      :post_soap,      :put_soap,      :delete_soap,
      :get_json,      :post_json,      :put_json,      :delete_json,
      :get_ajax,      :post_ajax,      :put_ajax,      :delete_ajax,
      :get_ajax_json, :post_ajax_json, :put_ajax_json, :delete_ajax_json,
@@ -21,66 +20,134 @@ describe HTTPWrapper do
     let(:sample_url) { 'http://example.com' }
     let(:sample_url_with_basic_auth) { "http://#{basic_auth_login}:#{basic_auth_password}@example.com" }
 
-    it 'should raise UnknownParameterError if initial options key is unknown' do
-      expect do
-        HTTPWrapper.new unknown_option: 'test', maybe_this_known: '?'
-      end.to raise_error HTTPWrapper::UnknownParameterError, 'Unknown options: unknown_option, maybe_this_known'
-    end
+    context 'Options' do
+      it 'should raise UnknownParameterError if initial options key is unknown' do
+        expect do
+          HTTPWrapper.new unknown_option: 'test', maybe_this_known: '?'
+        end.to raise_error HTTPWrapper::UnknownParameterError, 'Unknown options: unknown_option, maybe_this_known'
+      end
+
+      it 'should raise UnknownParameterError if params key is unknown' do
+        expect do
+          subject.get sample_url, unknown_param_key: 'test', another_param_key: 'wow'
+        end.to raise_error HTTPWrapper::UnknownParameterError, 'Unknown parameters: unknown_param_key, another_param_key'
+      end
+
+      it 'should follow redirects no more then 10 times by default' do
+        stub_redirects sample_url, 9
+        response = subject.get sample_url
+        response.code.should eql '200'
+
+        stub_redirects sample_url, 10
+        expect { subject.get sample_url }.to raise_error HTTPWrapper::TooManyRedirectsError, 'Too many redirects!'
+      end
+
+      it 'should follow redirects no more times then specified' do
+        subject.max_redirects = 5
 
-    it 'should raise UnknownParameterError if params key is unknown' do
-      expect do
-        subject.get sample_url, unknown_param_key: 'test', another_param_key: 'wow'
-      end.to raise_error HTTPWrapper::UnknownParameterError, 'Unknown parameters: unknown_param_key, another_param_key'
+        stub_redirects sample_url, 4
+        response = subject.get sample_url
+        response.code.should eql '200'
+
+        stub_redirects sample_url, 5
+        expect { subject.get sample_url }.to raise_error HTTPWrapper::TooManyRedirectsError, 'Too many redirects!'
+      end
+
+      it 'should use logger' do
+        require 'logger'
+        logger = Logger.new StringIO.new
+        logger.should_receive(:<<).at_least(:once)
+        subject.logger = logger
+
+        WebMock.allow_net_connect!
+        begin
+          subject.get 'localhost'
+        rescue
+          # NOOP, rescue from "connection refused" and such
+        end
+        WebMock.disable_net_connect!
+      end
     end
 
     context 'GET' do
+      it 'should add http uri scheme if missing' do
+        stub_get sample_url
+        subject.get sample_url.gsub(/\Ahttp:\/\//, '')
+      end
+
       it 'should hit provided url with default content type' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::DEFAULT_CONTENT_TYPE} }
+        params = { headers: {HTTPWrapper::HEADER::CONTENT_TYPE => HTTPWrapper::CONTENT_TYPE::DEFAULT} }
         stub_get sample_url, params
         subject.get sample_url
       end
 
       it 'should set content type if provided' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => 'Custom Content Type'} }
+        params = { headers: {HTTPWrapper::HEADER::CONTENT_TYPE => 'Custom Content Type'} }
         stub_get sample_url, params
         subject.get sample_url, params
+        subject.get sample_url, content_type: 'Custom Content Type'
+        subject.get sample_url, params.merge({content_type: 'Should Be Overwritten'})
       end
 
       it 'should set proper header for JSON requests' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::JSON_CONTENT_TYPE} }
+        params = { headers: HTTPWrapper::JSON_HEADER }
         stub_get sample_url, params
         subject.get_json sample_url
       end
 
       it 'should set proper header for AJAX requests' do
-        params = { headers: {HTTPWrapper::HEADER_AJAX => HTTPWrapper::HEADER_AJAX_VALUE,
-                             HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::DEFAULT_CONTENT_TYPE } }
+        params = {
+          headers: {
+            HTTPWrapper::HEADER::CONTENT_TYPE => HTTPWrapper::CONTENT_TYPE::DEFAULT
+          }.merge(HTTPWrapper::AJAX_HEADER)
+        }
         stub_get sample_url, params
         subject.get_ajax sample_url
       end
 
       it 'should set proper headers for AJAX-JSON requests' do
-        params = { headers: {HTTPWrapper::HEADER_AJAX => HTTPWrapper::HEADER_AJAX_VALUE,
-                             HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::JSON_CONTENT_TYPE } }
+        params = { headers: HTTPWrapper::AJAX_JSON_HEADER }
         stub_get sample_url, params
         subject.get_ajax_json sample_url
       end
 
       it 'should correctly escape query parameters' do
         stub_get sample_url + '/?param1=&param2=A%26B&param3=C%20%26%20D'
-        subject.get sample_url, params: {param1: '', param2: 'A&B', param3: 'C & D'}
+        subject.get sample_url, query: {param1: '', param2: 'A&B', param3: 'C & D'}
       end
 
       it 'should set default user agent' do
-        params = { headers: {HTTPWrapper::HEADER_USER_AGENT => HTTPWrapper.default_user_agent} }
+        params = { headers: {HTTPWrapper::HEADER::USER_AGENT => HTTPWrapper::USER_AGENT} }
         stub_get sample_url, params
         subject.get sample_url
       end
 
       it 'should change user agent if provided' do
         custom_user_agent = 'Mozilla v1.2.3'
-        params = { headers: {HTTPWrapper::HEADER_USER_AGENT => custom_user_agent} }
+        params = { headers: {HTTPWrapper::HEADER::USER_AGENT => custom_user_agent} }
+        stub_get sample_url, params
+        subject.get sample_url, params
+
+        subject.get sample_url, user_agent: custom_user_agent
+
+        subject.user_agent = custom_user_agent
+        subject.get sample_url
+
+        expect do
+          subject.get sample_url, user_agent: 'abracadabra'
+        end.to raise_error WebMock::NetConnectNotAllowedError
+
+        expect do
+          subject.user_agent = 'another test'
+          subject.get sample_url
+        end.to raise_error WebMock::NetConnectNotAllowedError
+      end
+
+      it 'should precedence header user agent before params' do
+        params = { headers: {HTTPWrapper::HEADER::USER_AGENT => 'TestUserAgent'} }
         stub_get sample_url, params
+
+        subject.user_agent = 'Should Be Overwritten'
         subject.get sample_url, params
       end
 
@@ -97,24 +164,20 @@ describe HTTPWrapper do
         subject.get sample_url, auth: {login: basic_auth_login, password: basic_auth_password}
       end
 
-      it 'should follow redirects no more then 10 times' do
-        stub_redirects sample_url, 9
-        response = subject.get sample_url
-        response.code.should eql '200'
-
-        stub_redirects sample_url, 10
-        expect { subject.get sample_url }.to raise_error HTTPWrapper::TooManyRedirectsError, 'Too many redirects!'
-      end
-
       it 'should merge query parameters and params should take precedence' do
         stub_get sample_url + '/?text=edf&time=16:44&user=test'
-        subject.get(sample_url + '/?user=test&text=abc', params: {time: '16:44', text: 'edf'})
+        subject.get(sample_url + '/?user=test&text=abc', query: {time: '16:44', text: 'edf'})
+      end
+
+      it 'should equally treat header as string and header as symbol' do
+        stub_get sample_url, { headers: {'Content-Type' => 'Some Content Type'} }
+        subject.get sample_url, { headers: {content_type: 'Some Content Type'} }
       end
     end
 
     context 'POST' do
       it 'should set content type if provided' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => 'Custom Content Type'} }
+        params = { headers: {HTTPWrapper::HEADER::CONTENT_TYPE => 'Custom Content Type'} }
         stub_post sample_url, params
         subject.post sample_url, params
       end
@@ -128,15 +191,37 @@ describe HTTPWrapper do
       end
 
       it 'should hit provided url with default content type' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::POST_CONTENT_TYPE } }
+        params = { headers: {HTTPWrapper::HEADER::CONTENT_TYPE => HTTPWrapper::CONTENT_TYPE::POST } }
         stub_post sample_url, params
         subject.post sample_url
       end
+
+      it 'should set all possible parameters correctly' do
+        stub_request(:post, 'http://user:passw@example.com/?a=b&c=d').
+            with(body: {
+            e: 'f',
+            g: 'k'
+        },
+                 headers: {
+                     'Content-Type' => 'Custom content type',
+                     'User-Agent' => 'Custom user agent',
+                     'Cookie' => 'cookie',
+                     'X-Requested-With' => 'XMLHttpRequest'
+                 })
+
+        subject.post sample_url, content_type: 'Custom content type',
+                     user_agent: 'Custom user agent',
+                     headers: {x_requested_with: 'XMLHttpRequest'},
+                     query: {a: 'b', c: 'd'},
+                     body: {e: 'f', g: 'k'},
+                     auth: {login: 'user', password: 'passw'},
+                     cookie: 'cookie'
+      end
     end
 
     context 'PUT' do
       it 'should hit provided url with default content type' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::POST_CONTENT_TYPE } }
+        params = { headers: {HTTPWrapper::HEADER::CONTENT_TYPE => HTTPWrapper::CONTENT_TYPE::POST } }
         stub_put sample_url, params
         subject.put sample_url
       end
@@ -144,11 +229,27 @@ describe HTTPWrapper do
 
     context 'DELETE' do
       it 'should hit provided url with default content type' do
-        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::POST_CONTENT_TYPE } }
+        params = { headers: {HTTPWrapper::HEADER::CONTENT_TYPE => HTTPWrapper::CONTENT_TYPE::DEFAULT } }
         stub_delete sample_url, params
         subject.delete sample_url
       end
     end
+
+    context 'Custom request instance' do
+      it 'should perform request for custom Net::HTTP request instance' do
+        stub_request :head, sample_url
+        uri = URI sample_url
+
+        if RUBY_VERSION =~ /\A2/
+          request = Net::HTTP::Head.new uri
+          subject.execute request, request.uri
+        else
+          # Ruby v1.9.3 doesn't understand full URI object, it needs just path :(
+          request = Net::HTTP::Head.new uri.request_uri
+          subject.execute request, uri
+        end
+      end
+    end
   end
 
   context 'HTTPS' do

data/spec/spec_helper.rb

@@ -1,6 +1,11 @@
 require 'rspec'
 require 'webmock/rspec'
 
+if ENV['TRAVIS'] == 'true'
+  require 'coveralls'
+  Coveralls.wear!
+end
+
 $LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
 
 module HTTPWrapperSpecHelpers
@@ -23,6 +28,5 @@ module HTTPWrapperSpecHelpers
 end
 
 RSpec.configure do |config|
-  config.mock_with :mocha
   config.include HTTPWrapperSpecHelpers
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http_wrapper
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -9,8 +9,36 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-09 00:00:00.000000000 Z
+date: 2013-09-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -39,8 +67,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.13.0
-description: Simple wrapper around standard Net::HTTP library to simplify common http[s]
-  tasks usage
+description: Simple wrapper around standard Net::HTTP library with multipart/form-data
+  file upload ability
 email: leonid@svyatov.ru
 executables: []
 extensions: []
@@ -54,6 +82,7 @@ files:
 - lib/http_wrapper/constants.rb
 - lib/http_wrapper/errors.rb
 - lib/http_wrapper/http_wrapper.rb
+- lib/http_wrapper/request.rb
 - lib/http_wrapper/version.rb
 - lib/http_wrapper.rb
 - spec/http_wrapper_spec.rb
@@ -78,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.7
+rubygems_version: 2.1.4
 signing_key: 
 specification_version: 4
 summary: Simple wrapper around standard Net::HTTP library