excon 0.62.0 → 0.92.3

data/benchmarks/excon_vs.rb

@@ -1,165 +0,0 @@
-require 'rubygems' if RUBY_VERSION < '1.9'
-require 'bundler'
-
-Bundler.require(:default)
-Bundler.require(:benchmark)
-
-require 'sinatra/base'
-
-require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'excon')
-
-module Excon
-  class Server < Sinatra::Base
-
-    def self.run
-      Rack::Handler::WEBrick.run(
-        Excon::Server.new,
-        :Port => 9292,
-        :AccessLog => [],
-        :Logger => WEBrick::Log.new(nil, WEBrick::Log::ERROR)
-      )
-    end
-
-    get '/data/:amount' do |amount|
-      'x' * amount.to_i
-    end
-
-  end
-end
-
-def with_server(&block)
-  pid = Process.fork do
-    Excon::Server.run
-  end
-  loop do
-    sleep(1)
-    begin
-      Excon.get('http://localhost:9292/api/foo')
-      break
-    rescue
-    end
-  end
-  yield
-ensure
-  Process.kill(9, pid)
-end
-
-require 'em-http-request'
-require 'httparty'
-require 'net/http'
-require 'open-uri'
-require 'rest_client'
-require 'tach'
-require 'typhoeus'
-
-size = 10_000
-path = '/data/' << size.to_s
-url = 'http://localhost:9292' << path
-
-times = 1_000
-
-with_server do
-
-  Tach.meter(times) do
-
-    tach('curb (persistent)') do |n|
-      curb = Curl::Easy.new
-
-      n.times do
-        curb.url = url
-        curb.http_get
-        curb.body_str
-      end
-    end
-
-    tach('em-http-request') do |n|
-      EventMachine.run {
-        count = 0
-
-        n.times do
-          http = EventMachine::HttpRequest.new(url).get
-
-          http.callback {
-            http.response
-            count += 1
-            EM.stop if count == n
-          }
-
-          http.errback {
-            http.response
-            count += 1
-            EM.stop if count == n
-          }
-        end
-      }
-    end
-
-    tach('Excon') do
-      Excon.get(url).body
-    end
-
-    excon = Excon.new(url)
-    tach('Excon (persistent)') do
-      excon.request(:method => 'get').body
-    end
-
-    tach('HTTParty') do
-      HTTParty.get(url).body
-    end
-
-    tach('Net::HTTP') do
-      # Net::HTTP.get('localhost', path, 9292)
-      Net::HTTP.start('localhost', 9292) {|http| http.get(path).body }
-    end
-
-    Net::HTTP.start('localhost', 9292) do |http|
-      tach('Net::HTTP (persistent)') do
-        http.get(path).body
-      end
-    end
-
-    tach('open-uri') do
-      open(url).read
-    end
-
-    tach('RestClient') do
-      RestClient.get(url)
-    end
-
-    streamly = StreamlyFFI::Connection.new
-    tach('StreamlyFFI (persistent)') do
-      streamly.get(url)
-    end
-
-    tach('Typhoeus') do
-      Typhoeus::Request.get(url).body
-    end
-
-  end
-end
-
-# +--------------------------+----------+
-# | tach                     | total    |
-# +--------------------------+----------+
-# | Excon (persistent)       | 1.529095 |
-# +--------------------------+----------+
-# | curb (persistent)        | 1.740387 |
-# +--------------------------+----------+
-# | Typhoeus                 | 1.876236 |
-# +--------------------------+----------+
-# | Excon                    | 2.001858 |
-# +--------------------------+----------+
-# | StreamlyFFI (persistent) | 2.200701 |
-# +--------------------------+----------+
-# | Net::HTTP                | 2.395704 |
-# +--------------------------+----------+
-# | Net::HTTP (persistent)   | 2.418099 |
-# +--------------------------+----------+
-# | HTTParty                 | 2.659317 |
-# +--------------------------+----------+
-# | RestClient               | 2.958159 |
-# +--------------------------+----------+
-# | open-uri                 | 2.987051 |
-# +--------------------------+----------+
-# | em-http-request          | 4.123798 |
-# +--------------------------+----------+

data/benchmarks/for_vs_array_each.rb

@@ -1,27 +0,0 @@
-require 'rubygems'
-require 'tach'
-
-data = ["some", "var", "goes", "in", :here, 0]
-Tach.meter(1_000_000) do
-  tach('for') do
-    for element in data
-      element == nil
-    end
-  end
-  tach('each') do
-    data.each do |element|
-      element == nil
-    end
-  end
-end
-
-# ruby 1.8.7 (2009-06-12 patchlevel 174) [universal-darwin10.0]
-# 
-# +------+----------+
-# | tach | total    |
-# +------+----------+
-# | for  | 2.958672 |
-# +------+----------+
-# | each | 2.983550 |
-# +------+----------+
-# 

data/benchmarks/for_vs_hash_each.rb

@@ -1,27 +0,0 @@
-require 'rubygems'
-require 'tach'
-
-data = {"some" => "var", "goes" => "in", :here => 0}
-Tach.meter(1_000_000) do
-  tach('for') do
-    for key, values in data
-      key == values
-    end
-  end
-  tach('each') do
-    data.each do |key, values|
-      key == values
-    end
-  end
-end
-
-# ruby 1.8.7 (2009-06-12 patchlevel 174) [universal-darwin10.0]
-# 
-# +------+----------+
-# | tach | total    |
-# +------+----------+
-# | each | 2.748909 |
-# +------+----------+
-# | for  | 2.949512 |
-# +------+----------+
-#

data/benchmarks/has_key-vs-lookup.rb

@@ -1,177 +0,0 @@
-# Copied from my benchmark_hell repo: github.com/sgonyea/benchmark_hell
-
-require 'benchmark'
-
-iters = 1000000
-hash  = {
-  'some_key' => 'some_val',
-  'nil_key' => nil
-}
-
-puts 'Hash#has_key vs. Hash#[]'
-Benchmark.bmbm do |x|
-  x.report('Hash#has_key') do
-    iters.times.each do
-      hash.has_key? 'some_key'
-    end
-  end
-
-  x.report('Hash#has_key (if statement)') do
-    iters.times.each do
-      if hash.has_key?('other_key')
-        "hooray!"
-      end
-    end
-  end
-
-  x.report('Hash#has_key (non-existant)') do
-    iters.times.each do
-      hash.has_key? 'other_key'
-    end
-  end
-
-  x.report('Hash#[]') do
-    iters.times.each do
-      hash['some_key']
-    end
-  end
-
-  x.report('Hash#[] (if statement)') do
-    iters.times.each do
-      if hash['some_key']
-        "hooray!"
-      end
-    end
-  end
-
-  x.report('Hash#[] (non-existant)') do
-    iters.times.each do
-      hash['other_key']
-    end
-  end
-
-  x.report('Hash#has_key (if statement) explicit nil check') do
-    iters.times.each do
-      if hash.has_key?('nil_key') && !hash['nil_key'].nil?
-        "hooray!"
-      end
-    end
-  end
-
-
-  x.report('Hash#has_key (if statement) implicit nil check') do
-    iters.times.each do
-      if hash.has_key?('nil_key') && hash['nil_key']
-        "hooray!"
-      end
-    end
-  end
-
-  x.report('Hash#[] (if statement with nil)') do
-    iters.times.each do
-      if hash['nil_key']
-        "hooray!"
-      end
-    end
-  end
-end
-
-=begin
-
-$ rvm exec bash -c 'echo $RUBY_VERSION && ruby has_key-vs-hash\[key\].rb'
-
-jruby-1.5.6
-Hash#has_key vs. Hash#[]
-Rehearsal ---------------------------------------------------------------
-Hash#has_key                  0.410000   0.000000   0.410000 (  0.341000)
-Hash#has_key (if statement)   0.145000   0.000000   0.145000 (  0.145000)
-Hash#has_key (non-existant)   0.116000   0.000000   0.116000 (  0.116000)
-Hash#[]                       0.189000   0.000000   0.189000 (  0.189000)
-Hash#[] (if statement)        0.176000   0.000000   0.176000 (  0.176000)
-Hash#[] (non-existant)        0.302000   0.000000   0.302000 (  0.302000)
------------------------------------------------------- total: 1.338000sec
-
-                                  user     system      total        real
-Hash#has_key                  0.128000   0.000000   0.128000 (  0.128000)
-Hash#has_key (if statement)   0.128000   0.000000   0.128000 (  0.128000)
-Hash#has_key (non-existant)   0.153000   0.000000   0.153000 (  0.153000)
-Hash#[]                       0.206000   0.000000   0.206000 (  0.206000)
-Hash#[] (if statement)        0.182000   0.000000   0.182000 (  0.182000)
-Hash#[] (non-existant)        0.252000   0.000000   0.252000 (  0.252000)
-
-macruby-0.7.1
-Hash#has_key vs. Hash#[]
-Rehearsal ---------------------------------------------------------------
-Hash#has_key                  2.530000   0.050000   2.580000 (  1.917643)
-Hash#has_key (if statement)   2.590000   0.050000   2.640000 (  1.935221)
-Hash#has_key (non-existant)   2.580000   0.050000   2.630000 (  1.964230)
-Hash#[]                       2.240000   0.040000   2.280000 (  1.640999)
-Hash#[] (if statement)        3.620000   0.070000   3.690000 (  2.530248)
-Hash#[] (non-existant)        2.060000   0.040000   2.100000 (  1.473487)
------------------------------------------------------ total: 15.920000sec
-
-                                  user     system      total        real
-Hash#has_key                  2.230000   0.030000   2.260000 (  1.661843)
-Hash#has_key (if statement)   2.180000   0.040000   2.220000 (  1.605644)
-Hash#has_key (non-existant)   2.160000   0.040000   2.200000 (  1.582561)
-Hash#[]                       2.160000   0.030000   2.190000 (  1.581448)
-Hash#[] (if statement)        3.440000   0.070000   3.510000 (  2.393421)
-Hash#[] (non-existant)        2.330000   0.040000   2.370000 (  1.699338)
-
-rbx-head
-Hash#has_key vs. Hash#[]
-Rehearsal ---------------------------------------------------------------
-Hash#has_key                  0.660584   0.004932   0.665516 (  0.508601)
-Hash#has_key (if statement)   0.261708   0.000532   0.262240 (  0.263021)
-Hash#has_key (non-existant)   0.265908   0.000827   0.266735 (  0.259509)
-Hash#[]                       0.396607   0.001189   0.397796 (  0.372997)
-Hash#[] (if statement)        0.553003   0.001589   0.554592 (  0.543859)
-Hash#[] (non-existant)        0.323748   0.000884   0.324632 (  0.319055)
------------------------------------------------------- total: 2.471511sec
-
-                                  user     system      total        real
-Hash#has_key                  0.332239   0.000819   0.333058 (  0.333809)
-Hash#has_key (if statement)   0.284344   0.000521   0.284865 (  0.285330)
-Hash#has_key (non-existant)   0.339695   0.001301   0.340996 (  0.324259)
-Hash#[]                       0.298555   0.000368   0.298923 (  0.299557)
-Hash#[] (if statement)        0.392755   0.000773   0.393528 (  0.395473)
-Hash#[] (non-existant)        0.277721   0.000464   0.278185 (  0.278540)
-
-ruby-1.8.7-p330
-Hash#has_key vs. Hash#[]
-Rehearsal ---------------------------------------------------------------
-Hash#has_key                  0.450000   0.000000   0.450000 (  0.450143)
-Hash#has_key (if statement)   0.440000   0.000000   0.440000 (  0.448278)
-Hash#has_key (non-existant)   0.420000   0.000000   0.420000 (  0.416959)
-Hash#[]                       0.450000   0.000000   0.450000 (  0.450727)
-Hash#[] (if statement)        0.550000   0.000000   0.550000 (  0.555043)
-Hash#[] (non-existant)        0.530000   0.000000   0.530000 (  0.527189)
------------------------------------------------------- total: 2.840000sec
-
-                                  user     system      total        real
-Hash#has_key                  0.440000   0.000000   0.440000 (  0.447746)
-Hash#has_key (if statement)   0.450000   0.000000   0.450000 (  0.450331)
-Hash#has_key (non-existant)   0.420000   0.000000   0.420000 (  0.419157)
-Hash#[]                       0.450000   0.000000   0.450000 (  0.454438)
-Hash#[] (if statement)        0.570000   0.000000   0.570000 (  0.563948)
-Hash#[] (non-existant)        0.520000   0.000000   0.520000 (  0.527866)
-
-ruby-1.9.2-p136
-Hash#has_key vs. Hash#[]
-Rehearsal ---------------------------------------------------------------
-Hash#has_key                  0.690000   0.000000   0.690000 (  0.691657)
-Hash#has_key (if statement)   0.630000   0.000000   0.630000 (  0.638418)
-Hash#has_key (non-existant)   0.640000   0.000000   0.640000 (  0.637510)
-Hash#[]                       0.580000   0.000000   0.580000 (  0.584500)
-Hash#[] (if statement)        0.840000   0.010000   0.850000 (  0.837541)
-Hash#[] (non-existant)        0.810000   0.000000   0.810000 (  0.811598)
------------------------------------------------------- total: 4.200000sec
-
-                                  user     system      total        real
-Hash#has_key                  0.690000   0.000000   0.690000 (  0.694192)
-Hash#has_key (if statement)   0.640000   0.000000   0.640000 (  0.641729)
-Hash#has_key (non-existant)   0.630000   0.000000   0.630000 (  0.634470)
-Hash#[]                       0.580000   0.000000   0.580000 (  0.587844)
-Hash#[] (if statement)        0.830000   0.000000   0.830000 (  0.832323)
-Hash#[] (non-existant)        0.790000   0.010000   0.800000 (  0.791689)
-=end

data/benchmarks/headers_case_sensitivity.rb

@@ -1,83 +0,0 @@
-require 'rubygems'
-require 'stringio'
-require 'tach'
-
-def all_match_socket
-  io = StringIO.new
-  io << "Connection: close\n"
-  io << "Content-Length: 000\n"
-  io << "Content-Type: text/html\n"
-  io << "Date: Xxx, 00 Xxx 0000 00:00:00 GMT\n"
-  io << "Server: xxx\n"
-  io << "Transfer-Encoding: chunked\n"
-  io << "\n\n"
-  io.rewind
-  io
-end
-
-Formatador.display_line('all_match')
-Formatador.indent do
-  Tach.meter(10_000) do
-    tach('compare on read') do
-      socket, headers = all_match_socket, {}
-      until ((data = socket.readline).chop!).empty?
-        key, value = data.split(': ')
-        headers[key] = value
-        (key.casecmp('Transfer-Encoding') == 0) && (value.casecmp('chunked') == 0)
-        (key.casecmp('Connection') == 0) && (value.casecmp('close') == 0)
-        (key.casecmp('Content-Length') == 0)
-      end
-    end
-
-    tach('original') do
-      socket, headers = all_match_socket, {}
-      until ((data = socket.readline).chop!).empty?
-        key, value = data.split(': ')
-        headers[key] = value
-      end
-      headers.has_key?('Transfer-Encoding') && headers['Transfer-Encoding'].casecmp('chunked') == 0
-      headers.has_key?('Connection') && headers['Connection'].casecmp('close') == 0
-      headers.has_key?('Content-Length')
-    end
-  end
-end
-
-def none_match_socket
-  io = StringIO.new
-  io << "Cache-Control: max-age=0\n"
-  io << "Content-Type: text/html\n"
-  io << "Date: Xxx, 00 Xxx 0000 00:00:00 GMT\n"
-  io << "Expires: Xxx, 00 Xxx 0000 00:00:00 GMT\n"
-  io << "Last-Modified: Xxx, 00 Xxx 0000 00:00:00 GMT\n"
-  io << "Server: xxx\n"
-  io << "\n\n"
-  io.rewind
-  io
-end
-
-Formatador.display_line('none_match')
-Formatador.indent do
-  Tach.meter(10_000) do
-    tach('compare on read') do
-      socket, headers = none_match_socket, {}
-      until ((data = socket.readline).chop!).empty?
-        key, value = data.split(': ')
-        headers[key] = value
-        (key.casecmp('Transfer-Encoding') == 0) && (value.casecmp('chunked') == 0)
-        (key.casecmp('Connection') == 0) && (value.casecmp('close') == 0)
-        (key.casecmp('Content-Length') == 0)
-      end
-    end
-
-    tach('original') do
-      socket, headers = none_match_socket, {}
-      until ((data = socket.readline).chop!).empty?
-        key, value = data.split(': ')
-        headers[key] = value
-      end
-      headers.has_key?('Transfer-Encoding') && headers['Transfer-Encoding'].casecmp('chunked') == 0
-      headers.has_key?('Connection') && headers['Connection'].casecmp('close') == 0
-      headers.has_key?('Content-Length')
-    end
-  end
-end

data/benchmarks/headers_split_vs_match.rb

@@ -1,34 +0,0 @@
-require 'rubygems'
-require 'tach'
-
-data = "Content-Length: 100"
-Tach.meter(1_000_000) do
-  tach('regex') do
-    data.match(/(.*):\s(.*)/)
-    header = [$1, $2]
-  end
-  tach('split') do
-    header = data.split(': ', 2)
-  end
-  tach('split regex') do
-    header = data.split(/:\s*/, 2)
-  end
-end
-
-#  +-------------+----------+
-#  | tach        | total    |
-#  +-------------+----------+
-#  | split regex | 5.940233 |
-#  +-------------+----------+
-#  | split       | 7.327549 |
-#  +-------------+----------+
-#  | regex       | 8.736390 |
-#  +-------------+----------+
-
-# +-------+----------+----------+
-# | tach  | average  | total    |
-# +-------+----------+----------+
-# | regex | 4.680451 | 4.680451 |
-# +-------+----------+----------+
-# | split | 4.393218 | 4.393218 |
-# +-------+----------+----------+

data/benchmarks/implicit_block-vs-explicit_block.rb

@@ -1,98 +0,0 @@
-# Copied from my benchmark_hell repo: github.com/sgonyea/benchmark_hell
-
-require 'benchmark'
-
-iters = 1000000
-
-def do_explicit(&block)
-  var = "hello"
-  block.call(var)
-end
-
-def do_implicit
-  var = "hello"
-  yield(var)
-end
-
-puts 'explicit block vs implicit'
-Benchmark.bmbm do |x|
-  x.report('explicit') do
-    iters.times.each do
-      do_explicit {|var|
-        var << "goodbye"
-      }
-    end
-  end
-
-  x.report('implicit') do
-    iters.times.each do
-      do_implicit {|var|
-        var << "goodbye"
-      }
-    end
-  end
-end
-
-=begin
-rvm exec bash -c 'echo && echo $RUBY_VERSION && echo && ruby implicit_block-vs-explicit_block.rb'
-
-jruby-1.5.6
-
-explicit block vs implicit
-Rehearsal --------------------------------------------
-explicit   1.163000   0.000000   1.163000 (  1.106000)
-implicit   0.499000   0.000000   0.499000 (  0.499000)
------------------------------------ total: 1.662000sec
-
-               user     system      total        real
-explicit   0.730000   0.000000   0.730000 (  0.730000)
-implicit   0.453000   0.000000   0.453000 (  0.453000)
-
-macruby-0.7.1
-
-explicit block vs implicit
-Rehearsal --------------------------------------------
-explicit   5.070000   0.130000   5.200000 (  3.546388)
-implicit   3.140000   0.050000   3.190000 (  2.255986)
------------------------------------ total: 8.390000sec
-
-               user     system      total        real
-explicit   5.340000   0.140000   5.480000 (  3.774963)
-implicit   3.170000   0.060000   3.230000 (  2.279951)
-
-rbx-head
-
-explicit block vs implicit
-Rehearsal --------------------------------------------
-explicit   1.270136   0.006507   1.276643 (  1.181588)
-implicit   0.839831   0.002203   0.842034 (  0.820849)
------------------------------------ total: 2.118677sec
-
-               user     system      total        real
-explicit   0.960593   0.001526   0.962119 (  0.966404)
-implicit   0.700361   0.001126   0.701487 (  0.703591)
-
-ruby-1.8.7-p330
-
-explicit block vs implicit
-Rehearsal --------------------------------------------
-explicit   3.970000   0.000000   3.970000 (  3.985157)
-implicit   1.560000   0.000000   1.560000 (  1.567599)
------------------------------------ total: 5.530000sec
-
-               user     system      total        real
-explicit   3.990000   0.010000   4.000000 (  4.002637)
-implicit   1.560000   0.000000   1.560000 (  1.560901)
-
-ruby-1.9.2-p136
-
-explicit block vs implicit
-Rehearsal --------------------------------------------
-explicit   2.620000   0.010000   2.630000 (  2.633762)
-implicit   1.080000   0.000000   1.080000 (  1.076809)
------------------------------------ total: 3.710000sec
-
-               user     system      total        real
-explicit   2.630000   0.010000   2.640000 (  2.637658)
-implicit   1.070000   0.000000   1.070000 (  1.073589)
-=end

data/benchmarks/merging.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'tach'
-
-Tach.meter(10_000) do
-
-  tach('merge') do
-    default = { :a => 1, :b => 2 }
-    override = { :b => 3, :c => 4 }
-    override = default.merge(override)
-  end
-
-  tach('loop') do
-    default = { :a => 1, :b => 2 }
-    override = { :b => 3, :c => 4 }
-    for key, value in default
-      override[key] ||= default[key]
-    end
-    override
-  end
-
-end

data/benchmarks/single_vs_double_quotes.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'tach'
-
-Tach.meter(1_000_000) do
-  tach('double') do
-    "path"
-  end
-  tach('single') do
-    'path'
-  end
-end
-
-#  [double, single]
-#
-#  +--------+----------+
-#  | tach   | total    |
-#  +--------+----------+
-#  | single | 0.416340 |
-#  +--------+----------+
-#  | double | 0.416570 |
-#  +--------+----------+