http2 0.0.28 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a28eaa08bb929414333c763236db9b220a499eb8
-  data.tar.gz: 8cb38c1995fc84a1562b3c8a117ed702fff75db1
+SHA256:
+  metadata.gz: 856e9e6edf6d355dc73912489a6263a6a213abbaa1ec87f6fa4b5547f727f336
+  data.tar.gz: f4062dda7f2970331ab68a9e38095fe7bc729f61a27305e7eaea4ddb9a2d28fe
 SHA512:
-  metadata.gz: 63c24b5f90f05a1e8f67a59cbe7765475bd087ae384b873c47ee90794f52e1ea5c88386769e30bdc51234fde4f32ae2454d16e990acf13fc97ba5e7a81e4bcce
-  data.tar.gz: 0f42d6609f0520b481723dd5c0d648371cd8b2b0f050c6608f45e81b9a511c87d4a651942d168c21f92d30fbb08f826c40450666ec8da657ba5f27ef5b493242
+  metadata.gz: 8ca5c943ae78a977a5253487670755830ea8225b417f79238cbaff5cf6d4f3adabe1e572b6480325c19e6cb317f35e10d2ef491de79df9d15cc7f6f8014f2b13
+  data.tar.gz: aead6eadd6b8569bab500e3ebf64bea0188ebf06739c83ba78d1f1fcd70b3b3ac0a6ad2516610bdefd2751bc63acb53c352fbbc1e3e310931d41ab0b6bf72f18

data/README.md

@@ -1,41 +1,143 @@
+[![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}"
+Http2.new(host: "www.google.dk") do |http|
+  # Do requests here.
 end
 ```
 
+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
+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"
+```
+
+## Inspecting responses
+
+```ruby
+resp = http.get("path/to/something")
+resp.content_type #=> "text/html"
+resp.content_length #=> 136
+resp.header("content-length") #=> "136"
+resp.headers #=> {"content-type" => ["text/html"], "content-length" => ["136"]}
+resp.code #=> "200"
+resp.charset #=> "utf-8"
+resp.http_version #=> "1.1"
+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
 
@@ -45,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.
@@ -59,4 +182,3 @@ http.reconnect
 
 Copyright (c) 2012 Kasper Johansen. See LICENSE.txt for
 further details.
-

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,9 +3,10 @@ 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|
+# Http2.new(host: "www.somedomain.com", port: 80, ssl: false, debug: false) do |http|
 #  res = http.get("index.rhtml?show=some_page")
 #  html = res.body
 #  print html
@@ -15,52 +16,64 @@ 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.fetch(:host)
+  end
+
+  def port
+    @args.fetch(:port)
+  end
+
+  def ssl?
+    @args[:ssl] ? true : false
+  end
+
   def reconnect
     @connection.reconnect
   end
 
   def new_url
     builder = Http2::UrlBuilder.new
-    builder.host = @args[:host]
-    builder.port = @args[:port]
+    builder.host = host
+    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.
@@ -70,7 +83,7 @@ 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
@@ -86,26 +99,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
+      args = {url: args.first}
+    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.
@@ -116,13 +125,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}"
@@ -131,97 +140,120 @@ class Http2
 
     headers = {
       "Connection" => "Keep-Alive",
-      "User-Agent" => @uagent
+      "User-Agent" => @uagent,
+      "Host" => host_header
     }
 
-    #Possible to give custom host-argument.
-    host = args[:host] || @args[:host]
-    port = args[:port] || @args[: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
+    "<Http2 host: #{host}:#{port}>"
+  end
+
+  def inspect
+    to_s
   end
 
 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
@@ -231,21 +263,24 @@ 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
 
   def parse_init_args(args)
-    args = {:host => args} if args.is_a?(String)
+    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
@@ -253,7 +288,7 @@ private
     @autostate_values = {} if autostate
     @nl = @args[:nl] || "\r\n"
 
-    if !@args[:port]
+    unless @args[:port]
       if @args[:ssl]
         @args[:port] = 443
       else
@@ -273,4 +308,4 @@ private
       @raise_errors = false
     end
   end
-end
+end