http2 0.0.31 → 0.0.35

data/{include → lib/http2}/response_reader.rb

@@ -1,17 +1,21 @@
 class Http2::ResponseReader
   attr_reader :response
 
-  def initialize(args)
+  def initialize(args:, http2:, sock:, request:)
     @mode = "headers"
     @transfer_encoding = nil
-    @response = Http2::Response.new(request_args: args, debug: @debug)
+    @request = request
+    @response = Http2::Response.new(debug: http2.debug, request: request)
     @rec_count = 0
-    @args, @debug, @http2, @sock = args[:args], args[:http2].debug, args[:http2], args[:sock]
+    @args = args
+    @debug = http2.debug
+    @http2 = http2
+    @sock = sock
     @nl = @http2.nl
     @conn = @http2.connection
 
     read_headers
-    read_body if @length == nil || @length > 0
+    read_body if @length == nil || @length.positive?
     finish
   end
 
@@ -23,6 +27,7 @@ class Http2::ResponseReader
       if line == "\n" || line == "\r\n" || line == @nl
         puts "Http2: Changing mode to body!" if @debug
         raise "No headers was given at all? Possibly corrupt state after last request?" if @response.headers.empty?
+
         @mode = "body"
         @http2.on_content_call(@args, @nl)
         break
@@ -49,24 +54,20 @@ class Http2::ResponseReader
   end
 
   def finish
-    #Check if we should reconnect based on keep-alive-max.
-    if @keepalive_max == 1 || @connection == "close"
-      @conn.close unless @conn.closed?
-    end
+    # Check if we should reconnect based on keep-alive-max.
+    @conn.close if !@conn.closed? && (@keepalive_max == 1 || @connection == "close")
 
     # Validate that the response is as it should be.
     puts "Http2: Validating response." if @debug
 
-    unless @response.code
-      raise "No status-code was received from the server. Headers: '#{@response.headers}' Body: '#{@response.body}'."
-    end
+    raise "No status-code was received from the server. Headers: '#{@response.headers}' Body: '#{@response.body}'." unless @response.code
 
     @response.validate!
     check_and_decode
     @http2.autostate_register(@response) if @http2.args[:autostate]
     handle_errors
 
-    if response = check_and_follow_redirect
+    if (response = check_and_follow_redirect)
       @response = response
     end
   end
@@ -78,36 +79,45 @@ private
       url, args = url_and_args_from_location
 
       if redirect_using_same_connection?(args)
-        return @http2.get(url)
+        @http2.get(url)
       else
         ::Http2.new(args).get(url)
       end
     end
   end
 
-  REDIRECT_CODES = [302, 303, 307]
+  REDIRECT_CODES = [301, 302, 303, 307, 308].freeze
   def redirect_response?
-    REDIRECT_CODES.include?(@response.code.to_i) && @response.header?("location") && @http2.args[:follow_redirects]
+    REDIRECT_CODES.include?(response.code.to_i) && response.header?("location") && @http2.args[:follow_redirects]
   end
 
   def redirect_using_same_connection?(args)
     if !args[:host] || args[:host] == @args[:host]
-      return true
+      true
     else
-      return false
+      false
     end
   end
 
+  def url
+    @url ||= response.header("location")
+  end
+
   def url_and_args_from_location
-    uri = URI.parse(@response.header("location"))
+    uri = URI.parse(url)
+
     url = uri.path
-    url << "?#{uri.query}" if uri.query.to_s.length > 0
+    url << "?#{uri.query}" unless uri.query.to_s.empty?
+    url = url.gsub(/\A\//, "")
+
+    args = @http2.args
+      .reject { |k, _v| [:ssl, :port].include? k }
+      .merge(host: uri.host)
 
-    args = {host: uri.host}
     args[:ssl] = true if uri.scheme == "https"
     args[:port] = uri.port if uri.port
 
-    return [url, args]
+    [url, args]
   end
 
   def check_and_decode
@@ -122,8 +132,8 @@ private
 
       begin
         valid_string = ic.encode("UTF-8")
-      rescue
-        valid_string = untrusted_str.force_encoding("UTF-8").encode("UTF-8", :invalid => :replace, :replace => "").encode("UTF-8")
+      rescue StandardError
+        valid_string = untrusted_str.force_encoding("UTF-8").encode("UTF-8", invalid: :replace, replace: "").encode("UTF-8")
       end
 
       @response.body = valid_string
@@ -131,16 +141,21 @@ private
   end
 
   def handle_errors
-    return unless  @http2.raise_errors
+    return unless @http2.raise_errors
 
-    if @response.code == "500"
+    case @response.code
+    when "500"
       err = Http2::Errors::Internalserver.new("A internal server error occurred")
-    elsif @response.code == "403"
+    when "403"
       err = Http2::Errors::Noaccess.new("No access")
-    elsif @response.code == "400"
+    when "400"
       err = Http2::Errors::Badrequest.new("Bad request")
-    elsif @response.code == "404"
+    when "401"
+      err = Http2::Errors::Unauthorized.new("Unauthorized")
+    when "404"
       err = Http2::Errors::Notfound.new("Not found")
+    when "415"
+      err = Http2::Errors::UnsupportedMediaType.new("Unsupported media type")
     end
 
     if err
@@ -153,7 +168,13 @@ private
     if line
       @rec_count += line.length
     elsif !line && @rec_count <= 0
-      raise Errno::ECONNABORTED, "Server closed the connection before being able to read anything (KeepAliveMax: '#{@http2.keepalive_max}', Connection: '#{@connection}', PID: '#{Process.pid}')."
+      parts = [
+        "KeepAliveMax: '#{@http2.keepalive_max}'",
+        "Connection: '#{@connection}'",
+        "PID: '#{Process.pid}'"
+      ]
+
+      raise Errno::ECONNABORTED, "Server closed the connection before being able to read anything (#{parts.join(", ")})."
     end
   end
 
@@ -176,7 +197,7 @@ private
   end
 
   def parse_content_type(content_type_line)
-    if match_charset = content_type_line.match(/\s*;\s*charset=(.+)/i)
+    if (match_charset = content_type_line.match(/\s*;\s*charset=(.+)/i))
       @charset = match_charset[1].downcase
       @response.charset = @charset
       content_type_line.gsub!(match_charset[0], "")
@@ -185,15 +206,15 @@ private
     @response.content_type = content_type_line
   end
 
-  #Parse a header-line and saves it on the object.
+  # Parse a header-line and saves it on the object.
   #===Examples
   # http.parse_header("Content-Type: text/html\r\n")
   def parse_header(line)
-    if match = line.match(/^(.+?):\s*(.+)#{@nl}$/)
+    if (match = line.match(/^(.+?):\s*(.+)#{@nl}$/))
       key = match[1].downcase
       set_header_special_values(key, match[2])
       parse_normal_header(line, key, match[1], match[2])
-    elsif match = line.match(/^HTTP\/([\d\.]+)\s+(\d+)\s+(.+)$/)
+    elsif (match = line.match(/^HTTP\/([\d\.]+)\s+(\d+)\s+(.+)$/)) # rubocop:disable Style/RedundantRegexpEscape
       @response.code = match[2]
       @response.http_version = match[1]
       @http2.on_content_call(@args, line)
@@ -224,18 +245,16 @@ private
     @response.headers[key] = [] unless @response.headers.key?(key)
     @response.headers[key] << value
 
-    if key != "transfer-encoding" && key != "content-length" && key != "connection" && key != "keep-alive"
-      @http2.on_content_call(@args, line)
-    end
+    @http2.on_content_call(@args, line) if key != "transfer-encoding" && key != "content-length" && key != "connection" && key != "keep-alive"
   end
 
-  #Parses the body based on given headers and saves it to the result-object.
+  # Parses the body based on given headers and saves it to the result-object.
   # http.parse_body(str)
   def parse_body(line)
-    return :break if @length == 0
+    return :break if @length&.zero?
 
     if @transfer_encoding == "chunked"
-      return parse_body_chunked(line)
+      parse_body_chunked(line)
     else
       puts "Http2: Adding #{line.to_s.bytesize} to the body." if @debug
       @response.body << line
@@ -247,15 +266,16 @@ private
   def parse_body_chunked(line)
     len = line.strip.hex
 
-    if len > 0
+    if len.positive?
       read = @conn.read(len)
       return :break if read == "" || read == "\n" || read == "\r\n"
+
       @response.body << read
       @http2.on_content_call(@args, read)
     end
 
     nl = @conn.gets
-    if len == 0
+    if len.zero?
       if nl == "\n" || nl == "\r\n"
         return :break
       else

data/{include → lib/http2}/url_builder.rb

@@ -1,7 +1,7 @@
 class Http2::UrlBuilder
   attr_accessor :host, :port, :protocol, :path, :params
 
-  def initialize args = {}
+  def initialize
     @params = {}
   end
 
@@ -24,18 +24,18 @@ class Http2::UrlBuilder
       end
     end
 
-    return url_params
+    url_params
   end
 
   def build_path_and_params
-    url = "#{path}"
+    url = path.to_s
 
     if params?
       url << "?"
       url << build_params
     end
 
-    return url
+    url
   end
 
   def build
@@ -49,7 +49,7 @@ class Http2::UrlBuilder
 
     url << build_path_and_params
 
-    return url
+    url
   end
 
   def params?

data/{include → lib/http2}/utils.rb

@@ -2,36 +2,38 @@
 class Http2::Utils
   # URL-encodes a string.
   def self.urlenc(string)
-    #Thanks to CGI framework
+    # Thanks to CGI framework
     string.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/) do
-      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
-    end.tr(' ', '+')
+      "%#{Regexp.last_match(1).unpack("H2" * Regexp.last_match(1).bytesize).join("%").upcase}"
+    end.tr(" ", "+")
   end
 
   # URL-decodes a string.
   def self.urldec(string)
-    #Thanks to CGI framework
-    str = string.to_s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/) do
-      [$1.delete('%')].pack('H*')
+    # Thanks to CGI framework
+    string.to_s.tr("+", " ").gsub(/((?:%[0-9a-fA-F]{2})+)/) do
+      [Regexp.last_match(1).delete("%")].pack("H*")
     end
   end
 
   # Parses a cookies-string and returns them in an array.
   def self.parse_set_cookies(str)
-    str = "#{str}"
+    str = str.to_s
     return [] if str.empty?
+
     cookie_start_regex = /^(.+?)=(.*?)(;\s*|$)/
 
     match = str.match(cookie_start_regex)
     raise "Could not match cookie: '#{str}'" unless match
+
     str.gsub!(cookie_start_regex, "")
 
     cookie_data = {
       name: urldec(match[1].to_s),
-      value: self.urldec(match[2].to_s)
+      value: urldec(match[2].to_s)
     }
 
-    while match = str.match(/(.+?)=(.*?)(;\s*|$)/)
+    while (match = str.match(/(.+?)=(.*?)(;\s*|$)/))
       str = str.gsub(match[0], "")
       key = match[1].to_s.downcase
       value = match[2].to_s
@@ -45,6 +47,6 @@ class Http2::Utils
 
     cookie = Http2::Cookie.new(cookie_data)
 
-    return [cookie]
+    [cookie]
   end
 end

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")
@@ -17,45 +18,49 @@ require "string-cases"
 class Http2
   # 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, :ssl_skip_verify, :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.
@@ -82,7 +87,6 @@ class Http2
   #===Examples
   # http.destroy
   def destroy
-    @args = nil
     @cookies = nil
     @debug = nil
     @mutex = nil
@@ -104,9 +108,9 @@ class Http2
       raise "Invalid arguments: '#{args.class.name}'"
     end
 
-    raise "Invalid URL: '#{args[:url]}'" unless args[:url].to_s.split("\n").length == 1
+    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.
@@ -120,9 +124,9 @@ 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
 
@@ -143,18 +147,19 @@ class Http2
 
     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.encode64("#{@args[:proxy][:user]}:#{@args[:proxy][:passwd]}").strip}"
+      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.
@@ -172,34 +177,35 @@ class Http2
   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
+  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|
+    @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
 
-    return cstr
+    cstr
   end
 
   def cookie(name)
     name = name.to_s
     return @cookies.fetch(name) if @cookies.key?(name)
+
     raise "No cookie by that name: '#{name}' in '#{@cookies.keys.join(", ")}'"
   end
 
@@ -216,8 +222,8 @@ class Http2
   # 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
@@ -231,13 +237,13 @@ class Http2
 private
 
   def host_header
-    #Possible to give custom host-argument.
+    # Possible to give custom host-argument.
     host = args[:host] || self.host
     port = args[:port] || self.port
 
-    host_header_string = "#{host}" # Copy host string to avoid changing the original string if port has been given!
+    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]
-    return host_header_string
+    host_header_string
   end
 
   # Registers the states from a result.
@@ -247,7 +253,6 @@ private
 
     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
@@ -266,14 +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
@@ -281,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

data/spec/helpers.rb

@@ -17,13 +17,11 @@ module Helpers
   def with_http(args = {})
     with_webserver do |hayabusa|
       Http2.new({host: "localhost", port: hayabusa.port, encoding_gzip: false}.merge(args)) do |http|
-        begin
-          yield http
-        rescue Http2::Errors::Internalserver => e
-          puts "Body of error-response: #{e.response.body}"
-          raise e
-        end
+        yield http
       end
+    rescue Http2::Errors::Internalserver => e
+      puts "Body of error-response: #{e.response.body}"
+      raise e
     end
   end
 end

data/spec/http2/cookies_spec.rb

@@ -5,14 +5,14 @@ describe Http2 do
 
   it "should parse cookies and let them be read" do
     with_http do |http|
-      res = http.get("cookie_test.rhtml")
-      http.cookies.length.should eq 2
+      http.get("cookie_test.rhtml")
+      expect(http.cookies.length).to eq 2
 
       cookie = http.cookie("TestCookie")
-      cookie.name.should eq "TestCookie"
-      cookie.value.should eq "TestValue"
-      cookie.path.should eq "/"
-      cookie.expires.should > Time.now
+      expect(cookie.name).to eq "TestCookie"
+      expect(cookie.value).to eq "TestValue"
+      expect(cookie.path).to eq "/"
+      expect(cookie.expires).to be > Time.now
     end
   end
 end

data/spec/http2/get_request_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Http2::GetRequest do
+  it "reads the headers from the request" do
+    with_http do |http|
+      res = http.get("content_type_test.rhtml")
+      headers = res.request.headers_string
+      expect(headers).to include "GET /content_type_test.rhtml"
+    end
+  end
+end

data/spec/http2/post_data_generator_spec.rb

@@ -19,6 +19,7 @@ describe Http2::PostDataGenerator do
         }
       }
     ).generate
-    raise "Expected 'test1%5Border%5D%5B%5B%3ABnet_profile%2C+%22profile_id%22%5D%5D=5' but got: '#{res}'." if res != "test1%5Border%5D%5B%5B%3ABnet_profile%2C+%22profile_id%22%5D%5D=5"
+
+    expect(res).to eq "test1%5Border%5D%5B%5B%3ABnet_profile%2C+%22profile_id%22%5D%5D=5"
   end
 end

data/spec/http2/post_multipart_request_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Http2::PostMultipartRequest do
+  it "reads the headers from the request" do
+    with_http do |http|
+      res = http.post_multipart(url: "json_test.rhtml", post: {"test1" => "test2"})
+      headers = res.request.headers_string
+      expect(headers).to include "POST /json_test.rhtml"
+    end
+  end
+end

data/spec/http2/post_request_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Http2::PostRequest do
+  it "reads the headers from the request" do
+    with_http do |http|
+      res = http.post(url: "json_test.rhtml", json: {testkey: "testvalue"})
+      headers = res.request.headers_string
+      expect(headers).to include "POST /json_test.rhtml"
+    end
+  end
+end

data/spec/http2/response_reader_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Http2::ResponseReader do
+  it "#url_and_args_from_location" do
+    with_http(ssl_skip_verify: true, follow_redirects: true) do |http|
+      response = http.get("redirect_test.rhtml?redirect_to=https://www.google.dk")
+      expect(response.host).to eq "www.google.dk"
+      expect(response.ssl?).to eq true
+      expect(response.port).to eq 443
+    end
+  end
+end