http.rb 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1aa084204b33f143035faeb227200b624899c909
+  data.tar.gz: fed0d738b0d4482348b74e136388ae96520f9353
+SHA512:
+  metadata.gz: 700033cbab49f2cd006e9d35a0c38ad46f90487877e6929957f8339d045d4e9c92f841665839c5617dceb9c71252f1f03837d17840c4611683453f3b3a511ff0
+  data.tar.gz: 301840cf8085e1b47ff4a6ec7c099032351099fe9da205a8a6e8a14d3bbde5b2a71b9f2fc5244c7e3687e9424f3e10d4929151d69570bce51e73f7f30318458e

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'rspec', require: false
+  gem 'webmock', require: false
+end

data/README.md

@@ -0,0 +1,99 @@
+# HTTP
+
+## Description
+
+This has been a personal library which was begun many years ago, around the middle of 2009 from what I can ascertain, though in various guises it may have been as early as late 2007.  Assuming it was the former, it was long enough ago that it actually, sadly (given the diminutive size of this perhaps), predates Faraday by about 6 months (late 2009), http.rb by well over 2 years (late 2011), although it also happens to postdate HTTParty by about a year (mid 2008).  
+
+Like many others before and after me with their respective libraries, I created it to simplify the heinous interface that is Net::HTTP.  At the time of it's original creation I was doing a lot of a webscraping and didn't want a half-dozen line setup to make simple requests.  It has stood the test of time, for me personally insofar as the interface remaining simpler than most other similar libraries, though it is also less full featured, but nevertheless for it's tiny size it packs in quite a bit.  
+
+From inception to early 2013 this was used as a front-end for Mechanize for the purpose of being able to jump out of being a pure web client and to just 'go at' a resource I was after, but still return a Mechanize object so that I could then resume a web client session.  Eventually I decided to wrap Net::HTTP and then manually use Nokogiri instead, since I would either use Mechanize largely as is, or I simply wanted to make straight requests without caring about caching or cookies.  I may allow HTTP to again return Mechanize objects optionally at some point in future as that had it's benefits, but they weren't great enough for the complications it brought if I remember correctly.  
+
+Even so, through its various incarnations the goal has basically remained the same: to have a simple way of making HTTP requests in Ruby.  
+
+I'd never intended to publish this and had intended for it to remain a personal library, but decided to use it for a small project and so as it could be included with ease in a Gemfile it needed to be gemified and well here we are, rightly or wrongly.  
+
+Perhaps someone will appreciate its relative simplicity, since it is much smaller and the usage simpler than any of the other 'wrapper' libraries mentioned above at least, such that it can be read and comprehended in full in as little as a couple of minutes.  It does just enough to do most simple HTTP GET and POST requests as simply as should be.  
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+	gem 'HTTP'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install HTTP
+
+
+## Usage
+
+```Ruby
+# With just a URI
+
+HTTP.get('http://example.com')
+HTTP.post('http://example.com') # Admittedly doing a POST without providing form data probably doesn't make much sense.
+
+# With arguments only
+
+HTTP.get('http://example.com', {a: 1, b: 2})
+HTTP.post('http://example.com', {a: 1, b: 2})
+
+# With custom headers only
+
+HTTP.get('http://example.com', {}, {'User-Agent'=>'Custom'})
+HTTP.post('http://example.com', {}, {'User-Agent'=>'Custom'})
+
+# With options only
+
+HTTP.get('http://example.com', {}, {}, {use_ssl: true})
+HTTP.post('http://example.com', {}, {}, {use_ssl: true})
+
+# With a block
+
+HTTP.get('http://example.com') do |response|
+  # Do stuff with a subclass of Net::HTTPResponse here...
+end
+HTTP.post('http://example.com') do |response|
+  # Do stuff with a subclass of Net::HTTPResponse here...
+end
+
+# With the lot
+
+HTTP.get('http://example.com', {a: 1, b: 2}, {'User-Agent'=>'Custom'}, {use_ssl: true}) do |response|
+  # Do stuff with a subclass of Net::HTTPResponse here...
+end
+HTTP.post('http://example.com', {a: 1, b: 2}, {'User-Agent'=>'Custom'}, {use_ssl: true}) do |response|
+  # Do stuff with a subclass of Net::HTTPResponse here...
+end
+
+# Including it in a class
+
+class A
+  include HTTP
+  def a
+    get('http://example.com')
+  end
+end
+
+# Extending a class
+
+class A
+  extend HTTP
+  get('http://example.com')
+end
+
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/thoran/HTTP/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new pull request

data/http.rb.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name = 'http.rb'
+  s.version = '0.11.0'
+  s.date = '2015-03-19'
+
+  s.summary = "HTTP made easy."
+  s.description = "HTTP is the simplest HTTP mezzanine library for Ruby.  Supply a URI, \
+    some optional query arguments, some optional headers, and some other SSL or \
+    Net::HTTP options, and that's it!"
+  s.author = 'thoran'
+  s.email = 'code@thoran.com'
+  s.homepage = "http://github.com/thoran/HTTP"
+
+  s.files = [
+    'Gemfile',
+    'README.md',
+    'http.rb.gemspec',
+    Dir['lib/**/*.rb'],
+    Dir['spec/**/*.rb']
+  ].flatten
+
+  s.require_paths = ['lib']
+
+  s.has_rdoc = false
+end

data/lib/HTTP.rb

@@ -0,0 +1,16 @@
+# HTTP.rb
+# HTTP
+
+# 20150319
+# 0.11.0
+
+# Changes since 0.10:
+# 1. Removed HTTP/write.rb, since I wanted to reimplement it using standard File methods and not my custom written File.write.  It may stay gone, but I'm not sure yet...
+# 2. + HTTP.gemspec
+# 3. + README.md
+
+lib_dir = File.expand_path(File.join(__FILE__, '..'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'HTTP/get'
+require 'HTTP/post'

data/lib/HTTP/get.rb

@@ -0,0 +1,39 @@
+# HTTP/get.rb
+# HTTP.get
+
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+lib_dir = File.expand_path(File.join(__FILE__, '..', '..'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'Hash/x_www_form_urlencode'
+require 'Net/HTTP/Get/set_headers'
+require 'URI/Generic/use_sslQ'
+
+module HTTP
+
+  def get(uri, args = {}, headers = {}, options = {}, &block)
+    uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = options[:use_ssl] || uri.use_ssl?
+    http.verify_mode = options[:verify_mode] || OpenSSL::SSL::VERIFY_NONE
+    options.each{|k,v| http.send("#{k}=", v)}
+    request_object = Net::HTTP::Get.new(uri.request_uri + '?' + args.x_www_form_urlencode)
+    request_object.headers = headers
+    request_object.basic_auth(uri.user, uri.password) if uri.user
+    response = http.request(request_object)
+    if response.code =~ /^3/
+      response = get(response.header['location'], {}, {}, options, &block)
+    end
+    if block_given?
+      yield response
+    else
+      response
+    end
+  end
+
+  module_function :get
+
+end

data/lib/HTTP/post.rb

@@ -0,0 +1,40 @@
+# HTTP/post.rb
+# HTTP.post
+
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+lib_dir = File.expand_path(File.join(__FILE__, '..', '..'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'HTTP/get'
+require 'Net/HTTP/Post/set_headers'
+require 'URI/Generic/use_sslQ'
+
+module HTTP
+
+  def post(uri, form_data = {}, headers = {}, options = {}, &block)
+    uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = options[:use_ssl] || uri.use_ssl?
+    http.verify_mode = options[:verify_mode] || OpenSSL::SSL::VERIFY_NONE
+    options.each{|k,v| http.send("#{k}=", v)}
+    request_object = Net::HTTP::Post.new(uri.request_uri)
+    request_object.form_data = form_data
+    request_object.headers = headers
+    request_object.basic_auth(uri.user, uri.password) if uri.user
+    response = http.request(request_object)
+    if response.code =~ /^3/
+      response = get(response.header['location'], {}, {}, options, &block)
+    end
+    if block_given?
+      yield response
+    else
+      response
+    end
+  end
+
+  module_function :post
+
+end

data/lib/Hash/x_www_form_urlencode.rb

@@ -0,0 +1,20 @@
+# Hash/x_www_form_urlencode.rb
+# Hash#x_www_form_urlencode
+
+# 20130310
+# 0.0.0
+
+# Notes: Extracted from MtGox library.  
+
+# Todo: 
+# 1. I should separate out the functionality for adding '+' characters so as it can do both styles of encoding.  That way I could reuse the existing Hash/to_parameter_string method as well...  
+
+require 'String/url_encode'
+
+class Hash
+
+  def x_www_form_urlencode(joiner = '&')
+    inject([]){|a,e| a << "#{e.first.to_s.url_encode.gsub(/ /, '+')}=#{e.last.to_s.url_encode.gsub(/ /, '+')}" unless e.last.nil?; a}.join(joiner)
+  end
+
+end

data/lib/Net/HTTP/Get/set_headers.rb

@@ -0,0 +1,17 @@
+# Net/HTTP/Get/set_headers.rb
+# Net::HTTP::Get#set_headers
+
+# 20130310
+# 0.0.0
+
+# Notes:
+# 1. Using the date from when first created in HTTP.get/post as the creation date.
+
+class Net::HTTP::Get
+
+  def set_headers(headers = {})
+    headers.each{|k,v| self[k] = v}
+  end
+  alias_method :headers=, :set_headers
+
+end

data/lib/Net/HTTP/Post/set_headers.rb

@@ -0,0 +1,17 @@
+# Net/HTTP/Post/set_headers.rb
+# Net::HTTP::Post#set_headers
+
+# 20130309
+# 0.0.0
+
+# Notes:
+# 1. Using the date from when first created in HTTP.get/post as the creation date.
+
+class Net::HTTP::Post
+
+  def set_headers(headers = {})
+    headers.each{|k,v| self[k] = v}
+  end
+  alias_method :headers=, :set_headers
+
+end

data/lib/URI/Generic/use_sslQ.rb

@@ -0,0 +1,18 @@
+# URI/Generic/use_sslQ.rb
+# URI::Generic#use_ssl?
+
+# 20141113
+# 0.0.0
+
+# Notes:
+# 1. Using the date from when first created in HTTP.get/post as the creation date.
+
+module URI
+  class Generic
+
+    def use_ssl?
+      scheme == 'https' ? true : false
+    end
+
+  end
+end

data/spec/HTTP.rb

@@ -0,0 +1,12 @@
+# spec/HTTP.rb
+
+spec_dir = File.expand_path(File.join(__FILE__, '..'))
+$LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+
+require 'spec_helper'
+
+require 'HTTP/get'
+require 'HTTP/post'
+
+require 'HTTP/get_spec'
+require 'HTTP/post_spec'

data/spec/HTTP/get_spec.rb

@@ -0,0 +1,172 @@
+# spec/HTTP/get_spec.rb
+
+spec_dir = File.expand_path(File.join(__FILE__, '..', '..'))
+$LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+
+require 'spec_helper'
+require 'HTTP/get'
+
+WebMock.enable!
+WebMock.disable_net_connect!(allow_localhost: true)
+
+describe ".get" do
+
+  context "with uri-only supplied" do
+    before do
+      stub_request(:get, 'http://example.com/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    context "uri as a string" do
+      let(:uri){'http://example.com/path'}
+      let(:parsed_uri){URI.parse(uri)}
+      let(:net_http_object){Net::HTTP.new(parsed_uri.host, parsed_uri.port)}
+
+      it "creates an instance of URI" do
+        expect(URI).to receive(:parse).with(uri).and_return(parsed_uri)
+        HTTP.get(uri)
+      end
+
+      it "creates a new Net::HTTP object" do
+        expect(Net::HTTP).to receive(:new).with(parsed_uri.host, parsed_uri.port).and_return(net_http_object)
+        HTTP.get(uri)
+      end
+    end
+
+    context "uri as a URI" do
+      let(:uri_string){'http://example.com/path'}
+      let(:uri){URI.parse(uri_string)}
+      let(:net_http_object){Net::HTTP.new(uri.host, uri.port)}
+
+      it "returns an instance of URI" do
+        expect(uri).to eq(uri)
+        HTTP.get(uri)
+      end
+
+      it "creates a new Net::HTTP object" do
+        expect(Net::HTTP).to receive(:new).with(uri.host, uri.port).and_return(net_http_object)
+        HTTP.get(uri)
+      end
+    end
+  end
+
+  context "with args supplied" do
+    let(:uri){'http://example.com/path'}
+    let(:parsed_uri){URI.parse(uri)}
+    let(:args) do; {a: 1, b: 2}; end
+    let(:x_www_form_urlencoded_arguments) do; args.x_www_form_urlencode; end
+    let(:get_argument){parsed_uri.request_uri + '?' + x_www_form_urlencoded_arguments}
+    let(:request_object){Net::HTTP::Get.new(get_argument)}
+
+    before do
+      stub_request(:get, 'http://example.com/path?a=1&b=2').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "x_www_form_urlencode's the args" do
+      expect(args).to receive(:x_www_form_urlencode).and_return(x_www_form_urlencoded_arguments)
+      HTTP.get(uri, args)
+    end
+
+    it "creates a new Net::HTTP::Get object" do
+      expect(Net::HTTP::Get).to receive(:new).with(get_argument).and_return(request_object)
+      HTTP.get(uri, args)
+    end
+  end
+
+  context "with headers supplied" do
+    let(:uri){'http://example.com/path'}
+    let(:parsed_uri){URI.parse(uri)}
+    let(:headers) do; {'User-Agent' => 'Rspec'}; end
+    let(:get_argument){parsed_uri.request_uri + '?'}
+    let(:request_object){Net::HTTP::Get.new(get_argument)}
+
+    before do
+      stub_request(:get, 'http://example.com/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Rspec'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "sets the headers on the request object" do
+      allow(Net::HTTP::Get).to receive(:new).with(get_argument).and_return(request_object)
+      HTTP.get(uri, {}, headers)
+      expect(request_object['User-Agent']).to eq('Rspec')
+    end
+  end
+
+  context "with options supplied" do
+    let(:uri){'http://example.com/path'}
+    let(:parsed_uri){URI.parse(uri)}
+    let(:net_http_object){Net::HTTP.new(parsed_uri.host, parsed_uri.port)}
+    let(:options) do; {use_ssl: true}; end
+
+    before do
+      stub_request(:get, 'https://example.com:80/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "sets the use_ssl option on the Net::HTTP instance" do
+      allow(Net::HTTP).to receive(:new).with(parsed_uri.host, parsed_uri.port).and_return(net_http_object)
+      HTTP.get(uri, {}, {}, options)
+      expect(net_http_object.instance_variable_get(:@use_ssl)).to be_truthy
+    end
+  end
+
+  context "with block supplied" do
+    let(:uri){'http://example.com/path'}
+
+    before do
+      stub_request(:get, 'http://example.com/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "yields an instance of Net::HTTPResponse" do
+      expect{|b| HTTP.get(uri, &b)}.to yield_with_args(Net::HTTPResponse)
+      HTTP.get(uri){|response|}
+    end
+  end
+
+  context "with redirection" do
+    let(:request_uri){'http://example.com/path'}
+    let(:redirect_uri){'http://redirected.com'}
+
+    before do
+      stub_request(:get, redirect_uri).
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    context "via 301" do
+      before do
+        stub_request(:get, request_uri).
+          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+            to_return(status: '301', body: '', headers: {'location' => redirect_uri})
+      end
+
+      it "does a redirect" do
+        expect(HTTP).to receive(:get).once.with(request_uri).and_call_original
+        expect(HTTP).to receive(:get).once.with(redirect_uri, {}, {}, {}).and_call_original
+        HTTP.get(request_uri)
+      end
+    end
+
+    context "via 302" do
+      before do
+        stub_request(:get, request_uri).
+          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+            to_return(status: '302', body: '', headers: {'location' => redirect_uri})
+      end
+
+      it "does a redirect" do
+        expect(HTTP).to receive(:get).with(request_uri).and_call_original
+        expect(HTTP).to receive(:get).with(redirect_uri, {}, {}, {}).and_call_original
+        HTTP.get(request_uri)
+      end
+    end
+  end
+
+end

data/spec/HTTP/post_spec.rb

@@ -0,0 +1,173 @@
+# spec/HTTP/post_spec.rb
+
+spec_dir = File.expand_path(File.join(__FILE__, '..', '..'))
+$LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+
+require 'spec_helper'
+require 'HTTP/post'
+
+WebMock.enable!
+WebMock.disable_net_connect!(allow_localhost: true)
+
+describe ".post" do
+
+  context "with uri-only supplied" do
+    before do
+      stub_request(:post, 'http://example.com/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    context "uri as a string" do
+      let(:uri){'http://example.com/path'}
+      let(:parsed_uri){URI.parse(uri)}
+      let(:net_http_object){Net::HTTP.new(parsed_uri.host, parsed_uri.port)}
+
+      it "creates an instance of URI" do
+        expect(URI).to receive(:parse).with(uri).and_return(parsed_uri)
+        HTTP.post(uri)
+      end
+
+      it "creates a new Net::HTTP object" do
+        expect(Net::HTTP).to receive(:new).with(parsed_uri.host, parsed_uri.port).and_return(net_http_object)
+        HTTP.post(uri)
+      end
+    end
+
+    context "uri as a URI" do
+      let(:uri_string){'http://example.com/path'}
+      let(:uri){URI.parse(uri_string)}
+      let(:net_http_object){Net::HTTP.new(uri.host, uri.port)}
+
+      it "returns an instance of URI" do
+        expect(uri).to eq(uri)
+        HTTP.post(uri)
+      end
+
+      it "creates a new Net::HTTP object" do
+        expect(Net::HTTP).to receive(:new).with(uri.host, uri.port).and_return(net_http_object)
+        HTTP.post(uri)
+      end
+    end
+  end
+
+  context "with form data supplied" do
+    let(:uri){'http://example.com/path'}
+    let(:parsed_uri){URI.parse(uri)}
+    let(:form_data) do; {a: 1, b: 2}; end
+    let(:encoded_form_data) do; form_data.x_www_form_urlencode; end
+    let(:request_uri){parsed_uri.request_uri}
+    let(:request_object){Net::HTTP::Post.new(request_uri)}
+
+    before do
+      stub_request(:post, "http://example.com/path").
+        with(body: {"a"=>"1", "b"=>"2"}, headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "sets the form data" do
+      allow(Net::HTTP::Post).to receive(:new).with(request_uri).and_return(request_object)
+      HTTP.post(uri, form_data)
+      expect(request_object.body).to eq(encoded_form_data)
+    end
+
+    it "creates a new Net::HTTP::Post object" do
+      expect(Net::HTTP::Post).to receive(:new).with(request_uri).and_return(request_object)
+      HTTP.post(uri, form_data)
+    end
+  end
+
+  context "with headers supplied" do
+    let(:uri){'http://example.com/path'}
+    let(:parsed_uri){URI.parse(uri)}
+    let(:headers) do; {'User-Agent' => 'Rspec'}; end
+    let(:request_uri){parsed_uri.request_uri}
+    let(:request_object){Net::HTTP::Post.new(request_uri)}
+
+    before do
+      stub_request(:post, 'http://example.com/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Rspec'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "sets the headers on the request object" do
+      allow(Net::HTTP::Post).to receive(:new).with(request_uri).and_return(request_object)
+      HTTP.post(uri, {}, headers)
+      expect(request_object['User-Agent']).to eq('Rspec')
+    end
+  end
+
+  context "with options supplied" do
+    let(:uri){'http://example.com/path'}
+    let(:parsed_uri){URI.parse(uri)}
+    let(:net_http_object){Net::HTTP.new(parsed_uri.host, parsed_uri.port)}
+    let(:options) do; {use_ssl: true}; end
+
+    before do
+      stub_request(:post, 'https://example.com:80/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "sets the use_ssl option on the Net::HTTP instance" do
+      allow(Net::HTTP).to receive(:new).with(parsed_uri.host, parsed_uri.port).and_return(net_http_object)
+      HTTP.post(uri, {}, {}, options)
+      expect(net_http_object.instance_variable_get(:@use_ssl)).to be_truthy
+    end
+  end
+
+  context "with block supplied" do
+    let(:uri){'http://example.com/path'}
+
+    before do
+      stub_request(:post, 'http://example.com/path').
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    it "yields an instance of Net::HTTPResponse" do
+      expect{|b| HTTP.post(uri, &b)}.to yield_with_args(Net::HTTPResponse)
+      HTTP.post(uri){|response|}
+    end
+  end
+
+  context "with redirection" do
+    let(:request_uri){'http://example.com/path'}
+    let(:redirect_uri){'http://redirected.com'}
+
+    before do
+      stub_request(:get, redirect_uri).
+        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(status: 200, body: '', headers: {})
+    end
+
+    context "via 301" do
+      before do
+        stub_request(:post, request_uri).
+          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+            to_return(status: '301', body: '', headers: {'location' => redirect_uri})
+      end
+
+      it "does a redirect" do
+        expect(HTTP).to receive(:post).once.with(request_uri).and_call_original
+        expect(HTTP).to receive(:get).once.with(redirect_uri, {}, {}, {}).and_call_original
+        HTTP.post(request_uri)
+      end
+    end
+
+    context "via 302" do
+      before do
+        stub_request(:post, request_uri).
+          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+            to_return(status: '302', body: '', headers: {'location' => redirect_uri})
+      end
+
+      it "does a redirect" do
+        expect(HTTP).to receive(:post).with(request_uri).and_call_original
+        expect(HTTP).to receive(:get).with(redirect_uri, {}, {}, {}).and_call_original
+        HTTP.post(request_uri)
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# spec/spec_helper.rb
+
+lib_dir = File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'webmock/rspec'
+WebMock.allow_net_connect!

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: http.rb
+version: !ruby/object:Gem::Version
+  version: 0.11.0
+platform: ruby
+authors:
+- thoran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-19 00:00:00.000000000 Z
+dependencies: []
+description: HTTP is the simplest HTTP mezzanine library for Ruby.  Supply a URI,     some
+  optional query arguments, some optional headers, and some other SSL or     Net::HTTP
+  options, and that's it!
+email: code@thoran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- http.rb.gemspec
+- lib/HTTP.rb
+- lib/HTTP/get.rb
+- lib/HTTP/post.rb
+- lib/Hash/x_www_form_urlencode.rb
+- lib/Net/HTTP/Get/set_headers.rb
+- lib/Net/HTTP/Post/set_headers.rb
+- lib/URI/Generic/use_sslQ.rb
+- spec/HTTP.rb
+- spec/HTTP/get_spec.rb
+- spec/HTTP/post_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/thoran/HTTP
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: HTTP made easy.
+test_files: []