httpsimple 1.0

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+gemspec
+
+group :test do
+  gem 'fakeweb'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Shawn Adams
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# httpsimple
+
+Thin wrapper around net/http. Handles HTTPS and follows redirects.
+
+## Install
+
+    $ gem install httpsimple
+
+## Examples
+
+### GET requests are simple
+```Ruby
+require 'httpsimple'
+# With parameters 
+response = HttpSimple.get('http://www.service.com/user', :username => 'bob')
+# Without
+response = HttpSimple.get('http://www.service.com/user')
+```
+<tt>response</tt> is a Net::HTTPOk object.
+
+### POST requests are simple
+```Ruby
+# Parameter as a Hash will send an application/x-www-form-urlencoded request
+response = HttpSimple.post('http://www.service.com/user', :username => 'bob')
+# You can also pass a string for the post body
+response = HttpSimple.post('http://www.service.com/user', 'I am the post body!')
+```
+
+### Headers are simple
+```Ruby
+url = 'http://service.com/user_add'
+response = HttpSimple.post(url, '<user>bob</user>') do |simple|
+	# 'simple' is an instance of HttpSimple::Http
+	simple.headers["Content-Type"] = "text/xml"
+end
+```
+
+### Other stuff you can set
+```Ruby
+url = 'https://www.service.com/login'
+response = HttpSimple.post(url, :username => 'bob', :password => '1234') do |simple|
+  # More headers
+  simple.headers['Accept'] = 'gzip, deflate' 
+  # Read time out (default 90)
+  simple.timeout = 120
+  # Max number of redirects to follow (default 3)
+  simple.max_redirects = 2
+  # Turn off ssl cert verification - dangerous
+  simple.strict_ssl = false
+end
+```
+
+## Response handlers
+
+You can register a code block to run when a certain http status code is received. Your code block
+should accept three arguments:
+
+1. Net::HTTP object.
+2. Net::HTTPRequest object.
+3. Net::HTTPResponse object.
+	
+```Ruby
+simple = HttpSimple.new
+simple.add_handler(200) do |http, req, res|
+	puts res.code # 200
+end
+simple.add_handler(301, 302) do |http, req, res|
+    puts "#{req.path} was redirected to #{res['location']}!"
+end
+res = simple.get("http://www.example.com")
+```
+
+### Remove response handlers
+```Ruby
+simple.remove_handler(200)
+```
+
+

data/lib/httpsimple.rb

@@ -0,0 +1,136 @@
+require 'net/http'
+require 'uri'
+
+module HttpSimple
+  def self.get(url, data=nil, &block)
+    request(url, :get, data, &block)
+  end
+  
+  def self.post(url, data=nil, &block)
+    request(url, :post, data, &block)
+  end  
+  
+  def self.new
+    Http.new
+  end
+  
+  def self.request(url, get_or_post, data, &block)
+    http = Http.new
+    block.call(http) unless block.nil?    
+    http.send(get_or_post, url, data)
+  end
+  private_class_method :request
+    
+  # Raised when max redirects exceeded.
+  class HTTPMaxRedirectError < StandardError
+    def initialize(max)
+      super("Max redirects (#{max}) exceeded.")
+    end
+  end
+  
+  class Http
+    attr_accessor :headers, :max_redirects, 
+      :strict_ssl, :timeout, :handlers
+    attr_reader :url
+    
+    def initialize  
+
+      @headers = {}
+      @max_redirects = 3 
+      @strict_ssl = true
+      @timeout = 90
+      # Response handlers
+      @handlers = {}
+                  
+    end
+    
+    def add_handler(*status_codes, &handler)
+      # Add response handle for http status code. ie 200, 302, 400
+      if block_given?
+        status_codes.each { |code| @handlers[code.to_s.to_sym] = handler }
+      end
+    end
+    
+    def remove_handler(*status_codes)
+      # Remove response handler for http status code.
+      status_codes.each { |code| @handlers.delete(code.to_s.to_sym) }
+    end
+    
+    def get(url, params=nil)
+      uri = URI(url)
+      uri.query = URI.encode_www_form(params) unless params.nil?
+      request = Net::HTTP::Get.new(uri.to_s)
+
+      if block_given?      
+        yield uri, request
+      else
+        fetch(uri, request, @max_redirects)      
+      end
+      
+    end
+    
+    def post(url, body=nil)
+      uri = URI(url)      
+      request = Net::HTTP::Post.new(uri.to_s)
+      
+      case body
+      when String
+        request.body = body
+      when Hash
+        request.set_form_data(body)
+      end
+      
+      if block_given?      
+        yield uri, request
+      else
+        fetch(uri, request, @max_redirects)      
+      end
+      
+    end
+     
+    def fetch(uri, request, limit=1)                
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @scrict_ssl
+      http.read_timeout = @timeout
+      
+      @headers.each_pair { |k,v| request[k] = v } unless @headers.empty?
+            
+      response = http.start do |http|
+        http.request(request)
+      end
+      
+      code = response.code.to_sym
+      if @handlers.key?(code)
+        @handlers[code].call(http, request, response)
+      end
+              
+      case response
+      when Net::HTTPSuccess
+        return response
+      when Net::HTTPRedirection
+        raise HTTPMaxRedirectError.new(@max_redirects) if limit == 0        
+        block = lambda { |url, req| fetch(url, req, limit - 1) }
+        if request.is_a? Net::HTTP::Get
+          get(response['location'], &block) 
+        elsif request.is_a? Net::HTTP::Post
+          post(response['location'], &block)
+        end
+      when Net::HTTPResponse
+        response.error!
+      end
+      
+    end
+    private :fetch
+    
+    def get_path(uri)
+      if uri.path.length == 0 and uri.query.nil?
+        "/"
+      elsif uri.query.nil?
+        uri.path
+      else
+        "#{uri.path}?#{uri.query}"
+      end
+    end
+  end    
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: httpsimple
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Shawn Adams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-10 00:00:00.000000000 Z
+dependencies: []
+description: ! "  Simple wrapper around Ruby's net/http library. It supports \n  redirects
+  and HTTPS.\n"
+email: ruby.httpsimple@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- LICENSE
+- lib/httpsimple.rb
+homepage: https://github.com/boris317/httpsimple
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple wrapper around Ruby's net/http
+test_files: []