http2 0.0.29 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 73d24887d39ea86831b94629d6dc98eed99333eb
-  data.tar.gz: 364f8d08601a1279bfdf2a214d02d545473a806a
+SHA256:
+  metadata.gz: 86c71528bc092c75bb6c6ec82ec5dc2dd8ca73bc7836ca235a8f66f7a8be26bd
+  data.tar.gz: 8eb7666d2020f5a38ae91c45d38f11cf772f136cb8a30c17c104d96743a6d967
 SHA512:
-  metadata.gz: a856ec3dd70d2db8640a53b109592acfd17af7ff66a3130a2200f4cf5b38317dc9e51cf2996a871a5d959f957de78361f63b069d88dc84d69fb19e8deeba9771
-  data.tar.gz: fd6d03348ab61b6b5b18cca4c0f27369d23bdf756d9f8fc9d5ee40a92e16fd90b054265f171b5ff8599f2141656873980011dfb0273096dc3cc0b690ed042d46
+  metadata.gz: 9411f817d1409689d895e01a6bb8cc22fe07f04c4e1b3ce03649ef23680da7dbc52fe3427c13171106453f3b08dc3e9f84cab938c1154bca0611e720d41e7c6e
+  data.tar.gz: b1214c3a8936c7fb605b731ed0b638a4aad0185890c3b58f4d083ac8ec950d3fe565e0bc863a29b3888d4e7762ed2b2e14237e5d2a51f2ba424fa50faa2cecdb

data/README.md

@@ -1,49 +1,122 @@
+[![Code Climate](https://codeclimate.com/github/kaspernj/http2.png)](https://codeclimate.com/github/kaspernj/http2)
+[![Build Status](https://www.peakflow.io/en/projects/http2/branch-statuses/master.svg
+)](https://www.peakflow.io/en/projects/http2/build-groups)
+
 # http2
 
-[![Build Status](https://api.shippable.com/projects/53bd3eef2e23bdcb03c0df9e/badge/master)](https://www.shippable.com/projects/53bd3eef2e23bdcb03c0df9e)
-[![Code Climate](https://codeclimate.com/github/kaspernj/http2.png)](https://codeclimate.com/github/kaspernj/http2)
-[![Code Climate](https://codeclimate.com/github/kaspernj/http2/coverage.png)](https://codeclimate.com/github/kaspernj/http2)
+A HTTP-framework for Ruby supporting keep-alive, compression, JSON-posting, detailed inspection of responses and much more.
 
-Example of usage:
+# Usage
 
 ```ruby
 require "rubygems"
 require "http2"
 
 Http2.new(host: "www.google.dk") do |http|
-  #Get-request.
-  res = http.get("path/to/something")
-  puts res.body
-  puts "All response-headers: #{res.headers}"
-  puts "Specific header: #{res.header("HeaderName")}"
-
-  #Post-request.
-  res = http.post(url: "path/to/something", post: {
-    "some_post_val" => "some_value"
-  })
-
-  res.content_type #=> "text/html"
-
-  #Post-multipart (upload).
-  res = http.post_multipart(url: "path/to/something", post: {
-    "test_file1" => {
-      fpath: fpath,
-      filename: "specfile"
-    }
-  })
-
-  puts "Cookies until now: #{http.cookies}"
+  # Do requests here.
 end
 ```
 
-## Get parameters.
+Or without using a block for ensuring closing of connection:
+```ruby
+http = Http2.new(...)
+
+# Do requests here.
+
+http.destroy # Closes the connection and frees up any variables used
+```
+
+Or through a proxy:
+```ruby
+Http2.new(host: "www.google.com", proxy: {host: "myproxy.com", port: 80, user: "myname", passwd: "mypassword"})
+```
+
+You can also use SSL:
+```ruby
+Http2.new(host: "myhost.com", ssl: true, ssl_skip_verify: true)
+```
+
+You can make it follow redirects like this:
+```ruby
+Http2.new(host: "myhost.com", follow_redirects: true)
+```
+
+## Get requests
+```ruby
+res = http.get("path/to/something")
+```
+
+Or as a hash:
+```ruby
+res = http.get(url: "path/to/something")
+```
+
+## Post requests
+```ruby
+res = http.post(url: "path/to/something", post: {
+  "some_post_val" => "some_value"
+})
+```
+
+### Extra headers
+```ruby
+res = http.post(
+  url: "path",
+  headers: {"Auth": "123"},
+  post: {data: "test"}
+)
+```
+
+### Post JSON as content
+```ruby
+res = http.post(url: "path/to/something", json: {some_argument: true})
+```
+
+### Reading JSON from request
+```ruby
+res = http.post(url: "something", json: {some_argument: true})
+res.json? #=> true (if content-type is application/json)
+res.json #=> {"value" => "something"}
+```
+
+## Delete requests
+```ruby
+res = http.delete(url: "path/to/something")
+```
+
+## File upload
+```ruby
+res = http.post_multipart(url: "path/to/something", post: {
+  "test_file1" => {
+    fpath: fpath,
+    filename: "specfile"
+  }
+})
+```
+
+## Reading cookies
+```ruby
+puts "Cookies until now: #{http.cookies}"
+```
 
+## Building URL's
 ```ruby
-http.host => example.com
-http.port => 80
+ub = ::Http2::UrlBuilder.new
+ub.host = "www.google.com"
+ub.port = 80
+ub.path = "script.php"
+ub.params["some_param"] = 2
+
+ub.build #=> "http://www.google.com/..."
+ub.build_params #=> "some_param=2&some_other_param=..."
+ub.build_path_and_params #=> "script.php?some_param=2"
+ub.params? #=> true
+ub.host #=> "www.google.com"
+ub.port #=> 80
+ub.path #=> "script.php"
 ```
 
-## Response details.
+## Inspecting responses
 
 ```ruby
 resp = http.get("path/to/something")
@@ -58,6 +131,13 @@ resp.body #=> "<html><body>..."
 resp.requested_url #=> "http://example.com/maybe/redirected/path/to/something"
 ```
 
+## Get parameters later.
+
+```ruby
+http.host #=> example.com
+http.port #=> 80
+```
+
 
 ## Reconnect
 
@@ -67,6 +147,27 @@ Handy when doing retries.
 http.reconnect
 ```
 
+
+## Basic HTTP authentication for all requests
+
+```ruby
+http = Http2.new(
+  host: "www.somehost.com",
+  basic_auth: {
+    user: "username",
+    passwd: "password"
+  }
+)
+```
+
+## Inspect the headers that were sent
+
+```ruby
+response = http.get("some_page")
+request = response.request
+request.headers_string #=> "GET /some_page\n..."
+```
+
 ## Contributing to http2
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.

data/Rakefile

@@ -1,49 +1,38 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'bundler'
+require "rubygems"
+require "bundler"
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  warn e.message
+  warn "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "http2"
-  gem.homepage = "http://github.com/kaspernj/http2"
-  gem.license = "MIT"
-  gem.summary = %Q{A lightweight framework for doing http-connections in Ruby. Supports cookies, keep-alive, compressing and much more.}
-  gem.description = %Q{A lightweight framework for doing http-connections in Ruby. Supports cookies, keep-alive, compressing and much more.}
-  gem.email = "k@spernj.org"
-  gem.authors = ["Kasper Johansen"]
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
+require "rake"
 
-require 'rspec/core'
-require 'rspec/core/rake_task'
+require "rspec/core"
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.pattern = FileList["spec/**/*_spec.rb"]
 end
 
 RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
+  spec.pattern = "spec/**/*_spec.rb"
   spec.rcov = true
 end
 
-task :default => :spec
+task default: :spec
 
-require 'rdoc/task'
+require "rdoc/task"
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  version = File.exist?("VERSION") ? File.read("VERSION") : ""
 
-  rdoc.rdoc_dir = 'rdoc'
+  rdoc.rdoc_dir = "rdoc"
   rdoc.title = "http2 #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
+
+Bundler::GemHelper.install_tasks
+
+require "best_practice_project"
+BestPracticeProject.load_tasks

data/lib/http2.rb

@@ -3,7 +3,8 @@ require "uri"
 require "monitor" unless ::Kernel.const_defined?(:Monitor)
 require "string-cases"
 
-#This class tries to emulate a browser in Ruby without any visual stuff. Remember cookies, keep sessions alive, reset connections according to keep-alive rules and more.
+# This class tries to emulate a browser in Ruby without any visual stuff.
+# Remember cookies, keep sessions alive, reset connections according to keep-alive rules and more.
 #===Examples
 # Http2.new(host: "www.somedomain.com", port: 80, ssl: false, debug: false) do |http|
 #  res = http.get("index.rhtml?show=some_page")
@@ -15,47 +16,51 @@ require "string-cases"
 #  print "#{res.headers}"
 # end
 class Http2
-  #Autoloader for subclasses.
+  # Autoloader for subclasses.
   def self.const_missing(name)
-    require "#{File.dirname(__FILE__)}/../include/#{::StringCases.camel_to_snake(name)}.rb"
-    return Http2.const_get(name)
-  end
+    file_path = "#{File.dirname(__FILE__)}/http2/#{::StringCases.camel_to_snake(name)}.rb"
 
-  #Converts a URL to "is.gd"-short-URL.
-  def self.isgdlink(url)
-    Http2.new(host: "is.gd") do |http|
-      resp = http.get("/api.php?longurl=#{url}")
-      return resp.body
+    if File.exist?(file_path)
+      require file_path
+      return Http2.const_get(name) if Http2.const_defined?(name)
     end
+
+    super
   end
 
   attr_reader :autostate, :connection, :cookies, :args, :debug, :mutex, :resp, :raise_errors, :nl
   attr_accessor :keepalive_max, :keepalive_timeout
 
-  VALID_ARGUMENTS_INITIALIZE = [:host, :port, :skip_port_in_host_header, :ssl, :nl, :user_agent, :raise_errors, :follow_redirects, :debug, :encoding_gzip, :autostate, :basic_auth, :extra_headers, :proxy]
+  VALID_ARGUMENTS_INITIALIZE = [
+    :host, :port, :skip_port_in_host_header, :ssl, :ssl_skip_verify, :nl, :user_agent, :raise_errors,
+    :follow_redirects, :debug, :encoding_gzip, :autostate, :basic_auth, :extra_headers, :proxy
+  ].freeze
   def initialize(args = {})
     @args = parse_init_args(args)
     set_default_values
     @cookies = {}
     @mutex = Monitor.new
-
     @connection = ::Http2::Connection.new(self)
 
     if block_given?
       begin
         yield(self)
       ensure
-        self.destroy
+        destroy
       end
     end
   end
 
   def host
-    @args[:host]
+    @args.fetch(:host)
   end
 
   def port
-    @args[:port]
+    @args.fetch(:port)
+  end
+
+  def ssl?
+    @args[:ssl] ? true : false
   end
 
   def reconnect
@@ -68,7 +73,7 @@ class Http2
     builder.port = port
     builder.protocol = @args[:protocol]
 
-    return builder
+    builder
   end
 
   # Closes current connection if any, changes the arguments on the object and reconnects keeping all cookies and other stuff intact.
@@ -78,11 +83,10 @@ class Http2
     @connection = ::Http2::Connection.new(self)
   end
 
-  #Destroys the object unsetting all variables and closing all sockets.
+  # Destroys the object unsetting all variables and closing all sockets.
   #===Examples
   # http.destroy
   def destroy
-    @args = nil
     @cookies = nil
     @debug = nil
     @mutex = nil
@@ -94,26 +98,22 @@ class Http2
     @connection = nil
   end
 
-  #Forces various stuff into arguments-hash like URL from original arguments and enables single-string-shortcuts and more.
+  # Forces various stuff into arguments-hash like URL from original arguments and enables single-string-shortcuts and more.
   def parse_args(*args)
     if args.length == 1 && args.first.is_a?(String)
       args = {url: args.first}
-    elsif args.length >= 2
-      raise "Couldnt parse arguments."
-    elsif args.is_a?(Array) && args.length == 1
+    elsif args.length == 1
       args = args.first
     else
-      raise "Invalid arguments: '#{args.class.name}'."
+      raise "Invalid arguments: '#{args.class.name}'"
     end
 
-    if args[:url].to_s.split("\n").length != 1
-      raise "Invalid URL: '#{args[:url]}'."
-    end
+    raise "Invalid URL: '#{args[:url]}'" if args[:url] != "" && args[:url].to_s.split("\n").length != 1
 
-    return args
+    args
   end
 
-  #Returns a result-object based on the arguments.
+  # Returns a result-object based on the arguments.
   #===Examples
   # res = http.get("somepage.html")
   # print res.body #=> <String>-object containing the HTML gotten.
@@ -124,13 +124,13 @@ class Http2
   # Proxies the request to another method but forces the method to be "DELETE".
   def delete(args)
     if args[:json]
-      return post(args.merge(method: :delete))
+      post(args.merge(method: :delete))
     else
-      return get(args.merge(method: :delete))
+      get(args.merge(method: :delete))
     end
   end
 
-  #Returns the default headers for a request.
+  # Returns the default headers for a request.
   #===Examples
   # headers_hash = http.default_headers
   # print "#{headers_hash}"
@@ -139,85 +139,91 @@ class Http2
 
     headers = {
       "Connection" => "Keep-Alive",
-      "User-Agent" => @uagent
+      "User-Agent" => @uagent,
+      "Host" => host_header
     }
 
-    #Possible to give custom host-argument.
-    host = args[:host] || self.host
-    port = args[:port] || self.port
-
-    headers["Host"] = host
-    headers["Host"] << ":#{port}" if port && ![80, 443].include?(port.to_i) && !@args[:skip_port_in_host_header]
     headers["Accept-Encoding"] = "gzip" if @args[:encoding_gzip]
 
     if @args[:basic_auth]
       require "base64" unless ::Kernel.const_defined?(:Base64)
-      headers["Authorization"] = "Basic #{Base64.encode64("#{@args[:basic_auth][:user]}:#{@args[:basic_auth][:passwd]}").strip}"
+      headers["Authorization"] = "Basic #{Base64.strict_encode64("#{@args[:basic_auth][:user]}:#{@args[:basic_auth][:passwd]}").strip}"
+    end
+
+    if @args[:proxy] && @args[:proxy][:user] && @args[:proxy][:passwd] && !@connection.proxy_connect?
+      require "base64" unless ::Kernel.const_defined?(:Base64)
+      puts "Http2: Adding proxy auth header to request" if @debug
+      headers["Proxy-Authorization"] = "Basic #{Base64.strict_encode64("#{@args[:proxy][:user]}:#{@args[:proxy][:passwd]}").strip}"
     end
 
     headers.merge!(@args[:extra_headers]) if @args[:extra_headers]
     headers.merge!(args[:headers]) if args[:headers]
-    return headers
+
+    headers
   end
 
-  #Posts to a certain page.
+  # Posts to a certain page.
   #===Examples
   # res = http.post("login.php", {"username" => "John Doe", "password" => 123)
   def post(args)
     ::Http2::PostRequest.new(self, args).execute
   end
 
-  #Posts to a certain page using the multipart-method.
+  # Posts to a certain page using the multipart-method.
   #===Examples
   # res = http.post_multipart("upload.php", {"normal_value" => 123, "file" => Tempfile.new(?)})
   def post_multipart(*args)
     ::Http2::PostMultipartRequest.new(self, *args).execute
   end
 
-  #Returns a header-string which normally would be used for a request in the given state.
-  def header_str(headers_hash, args = {})
-    headers_hash["Cookie"] = cookie_header_string
+  # Returns a header-string which normally would be used for a request in the given state.
+  def header_str(headers_hash)
+    headers_hash["Cookie"] = cookie_header_string unless cookie_header_string.empty?
 
     headers_str = ""
     headers_hash.each do |key, val|
       headers_str << "#{key}: #{val}#{@nl}"
     end
 
-    return headers_str
+    headers_str
   end
 
   def cookie_header_string
     cstr = ""
 
     first = true
-    @cookies.each do |cookie_name, cookie_data|
+    @cookies.each do |_cookie_name, cookie|
       cstr << "; " unless first
       first = false if first
+      ensure_single_lines([cookie.name, cookie.value])
+      cstr << "#{Http2::Utils.urlenc(cookie.name)}=#{Http2::Utils.urlenc(cookie.value)}"
+    end
 
-      if cookie_data.is_a?(Hash)
-        name = cookie_data["name"]
-        value = cookie_data["value"]
-      else
-        name = cookie_name
-        value = cookie_data
-      end
+    cstr
+  end
 
-      raise "Unexpected lines: #{value.lines.to_a.length}." if value.lines.to_a.length != 1
-      cstr << "#{Http2::Utils.urlenc(name)}=#{Http2::Utils.urlenc(value)}"
-    end
+  def cookie(name)
+    name = name.to_s
+    return @cookies.fetch(name) if @cookies.key?(name)
 
-    return cstr
+    raise "No cookie by that name: '#{name}' in '#{@cookies.keys.join(", ")}'"
+  end
+
+  def ensure_single_lines(*strings)
+    strings.each do |string|
+      raise "More than one line: #{string}." unless string.to_s.lines.to_a.length == 1
+    end
   end
 
   def on_content_call(args, str)
     args[:on_content].call(str) if args.key?(:on_content)
   end
 
-  #Reads the response after posting headers and data.
+  # Reads the response after posting headers and data.
   #===Examples
   # res = http.read_response
-  def read_response(args = {})
-    ::Http2::ResponseReader.new(http2: self, sock: @sock, args: args).response
+  def read_response(request, args = {})
+    ::Http2::ResponseReader.new(http2: self, sock: @sock, args: args, request: request).response
   end
 
   def to_s
@@ -230,14 +236,23 @@ class Http2
 
 private
 
-  #Registers the states from a result.
+  def host_header
+    # Possible to give custom host-argument.
+    host = args[:host] || self.host
+    port = args[:port] || self.port
+
+    host_header_string = host.dup # Copy host string to avoid changing the original string if port has been given!
+    host_header_string << ":#{port}" if port && ![80, 443].include?(port.to_i) && !@args[:skip_port_in_host_header]
+    host_header_string
+  end
+
+  # Registers the states from a result.
   def autostate_register(res)
     puts "Http2: Running autostate-register on result." if @debug
     @autostate_values.clear
 
     res.body.to_s.scan(/<input type="hidden" name="__(EVENTTARGET|EVENTARGUMENT|VIEWSTATE|LASTFOCUS)" id="(.*?)" value="(.*?)" \/>/) do |match|
       name = "__#{match[0]}"
-      id = match[1]
       value = match[2]
 
       puts "Http2: Registered autostate-value with name '#{name}' and value '#{value}'." if @debug
@@ -247,7 +262,7 @@ private
     raise "No states could be found." if @autostate_values.empty?
   end
 
-  #Sets the states on the given post-hash.
+  # Sets the states on the given post-hash.
   def autostate_set_on_post_hash(phash)
     phash.merge!(@autostate_values)
   end
@@ -256,12 +271,15 @@ private
     args = {host: args} if args.is_a?(String)
     raise "Arguments wasnt a hash." unless args.is_a?(Hash)
 
-    args.each do |key, val|
+    args.each_key do |key|
       raise "Invalid key: '#{key}'." unless VALID_ARGUMENTS_INITIALIZE.include?(key)
     end
 
+    args[:proxy][:connect] = true if args[:proxy] && !args[:proxy].key?(:connect) && args[:ssl]
+
     raise "No host was given." unless args[:host]
-    return args
+
+    args
   end
 
   def set_default_values
@@ -269,7 +287,7 @@ private
     @autostate_values = {} if autostate
     @nl = @args[:nl] || "\r\n"
 
-    if !@args[:port]
+    unless @args[:port]
       if @args[:ssl]
         @args[:port] = 443
       else