simple-http 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7bdabbc5ad9589138ddf4724fb952870d18da4f4f96d957fdc51a145d86adaf
-  data.tar.gz: 6a4842332bc30e54c0271cb70177efc5d6283197230eaf1e0c382f1528835574
+  metadata.gz: b513811215ed8543923236fd40336bd3989771cc85f7da2a2d6ecfff869c7bd4
+  data.tar.gz: 0a0718c191e4102a8a06162e92d295dcd519aaeb22fbb4997ee45a8b3a4e7a26
 SHA512:
-  metadata.gz: e8844fa1eb87462695fc7a82329e18055fa2bdf3ecf0dc251872fdec5c640fda6a532e86e82ca1048d5e78a5f7993769d4494ceca7973e51f310dd9cfac794c5
-  data.tar.gz: c37bedd490d573c8da46484d990ccb197dead457c00569e0b87eaa374f6cf36b39ef80941b5069406f8ab88dde2a74abd14ba12b168512019a30a27c052ac33c
+  metadata.gz: 2b304ffa55e45fdcc8c5c68b52d379dae57d38d07404c817a04de80409c0e161c75c6c94dff0cdbad81506ffee3e61e0569b33d1e20fd8fba77880e420694650
+  data.tar.gz: 429e91c1b979b1750cf4896b2ebf2a13cf072bb4e0418268573615273dd1a5785ef5eb6f9927851d55531eb41703d748d57fe9a8c59533c750e463147d486848

data/lib/simple-http.rb

@@ -1 +1,2 @@
+# rubocop:disable Naming/FileName
 require "simple/http"

data/lib/simple/http.rb

@@ -2,21 +2,23 @@
 # Copyright:: Copyright (c) 2011-2015 radiospiel
 # License::   Distributes under the terms  of the Modified BSD License, see LICENSE.BSD for details.
 
-require "net/http"
+# rubocop:disable Metrics/ClassLength
+
 require "json"
-require "logger"
+require "expectation"
 
 module Simple; end
 class Simple::HTTP; end
 
 require_relative "http/version"
+require_relative "http/helpers"
 require_relative "http/caching"
 require_relative "http/errors"
+require_relative "http/logger"
 require_relative "http/headers"
 require_relative "http/request"
 require_relative "http/response"
-
-require "openssl"
+require_relative "http/checked_response"
 
 #
 # A very simple, Net::HTTP-based HTTP client.
@@ -25,10 +27,6 @@ require "openssl"
 # requests are jsonized, and all data in responses are parsed as JSON if
 # the Content-Type header is set to "application/json".
 class Simple::HTTP
-  #
-  # The logger instance.
-  attr_accessor :logger
-
   #
   # The base URL when set, all requests that do not start with http: or
   # https: are done relative to this base URL.
@@ -40,44 +38,67 @@ class Simple::HTTP
   # error - which is probably only useful when testing an interface.
   attr_accessor :follows_redirections
 
+  #
+  # Always send these headers.
+  attr_reader :default_headers
+
+  def default_headers=(default_headers)
+    expect! default_params => [Hash, nil]
+    @default_headers = default_headers
+  end
+
   #
   # When set, appends this to all request URLs
-  attr_accessor :default_params
+  attr_reader :default_params
+
+  def default_params=(default_params)
+    expect! default_params => [Hash, String, nil]
+    @default_params = default_params
+  end
 
   #
   # When set, sets Authorization headers to all requests. Must be an
   # array [ username, password ].
   attr_accessor :basic_auth
 
-  def initialize
+  def initialize(base_url: nil)
+    self.default_headers = {}
+    self.default_params = nil
+    self.base_url = base_url
     self.follows_redirections = true
-    self.logger = Logger.new(STDERR, level: :warn)
   end
 
   def head(url, headers = {})
-    perform_request! :HEAD, url, nil, headers
+    perform_request!(:HEAD, url, nil, headers)
+  end
+
+  def head!(url, headers = {})
+    perform_request!(:HEAD, url, nil, headers)
   end
 
   def get(url, headers = {})
-    perform_request! :GET, url, nil, headers
+    perform_request!(:GET, url, nil, headers)
   end
 
   def options(url, headers = {})
-    perform_request! :OPTIONS, url, nil, headers
+    perform_request!(:OPTIONS, url, nil, headers)
   end
 
   def post(url, body = nil, headers = {})
-    perform_request! :POST, url, body, headers
+    perform_request!(:POST, url, body, headers)
   end
 
   def put(url, body = nil, headers = {})
-    perform_request! :PUT, url, body, headers
+    perform_request!(:PUT, url, body, headers)
   end
 
   def delete(url, headers = {})
-    perform_request! :DELETE, url, nil, headers
+    perform_request!(:DELETE, url, nil, headers)
   end
 
+  # adds get!, post!; etc.
+  include CheckedResponse
+
   #
   # -- Caching ----------------------------------------------------------------
 
@@ -94,18 +115,18 @@ class Simple::HTTP
       url = File.join(base_url, url)
     end
 
-    uri = URI.parse(url)
-    unless uri.is_a?(URI::HTTP)
-      raise ArgumentError, "Invalid URL: #{url}"
+    expect! url => /^http|https/
+
+    if default_headers
+      headers = headers.merge(default_headers)
     end
 
-    # append default_params, if set
-    if default_params
-      url.concat(url.include?("?") ? "&" : "?")
-      url.concat default_params
+    case default_params
+    when Hash then url = ::Simple::HTTP.build_url(url, default_params)
+    when String then url = url + (url.include?("?") ? "&" : "?") + default_params
     end
 
-    request = Request.new(verb: verb, url: url, body: body, headers: headers)
+    request = Request.build(verb: verb, url: url, body: body, headers: headers)
 
     execute_request(request)
   end
@@ -120,7 +141,7 @@ class Simple::HTTP
 
     raise ::Simple::HTTP::TooManyRedirections, response if max_redirections <= 0
 
-    request = ::Simple::HTTP::Request.new(verb: :GET, url: response.headers["Location"], headers: {})
+    request = ::Simple::HTTP::Request.build(verb: :GET, url: response.headers["Location"], headers: {})
     execute_request(request, max_redirections: max_redirections - 1)
   end
 
@@ -144,18 +165,54 @@ class Simple::HTTP
   def execute_request_w_logging(request)
     started_at = Time.now
 
-    response = driver.execute_request(request, client: self)
-    response.send(:set_request, request)
+    Simple::HTTP.logger.debug do
+      "> #{request}, w/headers #{request.headers}"
+    end
+
+    response_hsh = driver.execute_request(request, client: self)
+
+    status, message, headers, body = response_hsh.values_at :status, :message, :headers, :body
+
+    response = ::Simple::HTTP::Response.build request: request,
+                                              status: status,
+                                              message: message,
+                                              body: body,
+                                              headers: headers
 
-    logger.info do
-      "#{request}: #{response}, #{"%.3f secs" % (Time.now - started_at)}"
+    ::Simple::HTTP.logger.info do
+      # FIXME: for some reason the status message might contain a trailing space?
+      message = response.message.gsub(/ $/, "")
+      "#{request} #{response.status} #{"%.3f" % (Time.now - started_at)} secs: #{message}"
     end
 
     response
   end
 
+  def determine_driver
+    "default"
+
+    #   require "faraday"
+    #   "faraday"
+    # rescue LoadError
+    #   "default"
+  end
+
   def driver
-    require "simple/http/driver/default"
-    ::Simple::HTTP::Driver::Default
+    @driver ||= begin
+      driver_name = determine_driver
+      Simple::HTTP.logger.debug "simple-http: Using #{driver_name} driver"
+      driver_name
+    end
+
+    case @driver
+    when "faraday"
+      require "simple/http/driver/faraday"
+      ::Simple::HTTP::Driver::Faraday
+    when "default"
+      require "simple/http/driver/default"
+      ::Simple::HTTP::Driver::Default
+    else
+      raise "Internal error"
+    end
   end
 end

data/lib/simple/http/checked_response.rb

@@ -0,0 +1,28 @@
+module Simple::HTTP::CheckedResponse
+  SELF = self
+
+  def get!(url, headers = {}, into: nil)
+    response = perform_request!(:GET, url, nil, headers)
+    response.checked_content(into: into)
+  end
+
+  def options!(url, headers = {}, into: nil)
+    response = perform_request!(:OPTIONS, url, nil, headers)
+    response.checked_content(into: into)
+  end
+
+  def post!(url, body = nil, headers = {}, into: nil)
+    response = perform_request!(:POST, url, body, headers)
+    response.checked_content(into: into)
+  end
+
+  def put!(url, body = nil, headers = {}, into: nil)
+    response = perform_request!(:PUT, url, body, headers)
+    response.checked_content(into: into)
+  end
+
+  def delete!(url, headers = {}, into: nil)
+    response = perform_request!(:DELETE, url, nil, headers)
+    response.checked_content(into: into)
+  end
+end

data/lib/simple/http/driver/default.rb

@@ -1,4 +1,7 @@
-# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+# rubocop:disable Metrics/AbcSize
+
+require "net/http"
+require "openssl"
 
 module Simple::HTTP::Driver
 end
@@ -6,9 +9,7 @@ end
 module Simple::HTTP::Driver::Default
   extend self
 
-  #
-  # do a HTTP request, return its response or, when not successful,
-  # raise an error.
+  # does an HTTP request and returns its response.
   def execute_request(request, client:)
     verb, url, body, headers =
       request.verb, request.url, request.body, request.headers
@@ -20,12 +21,14 @@ module Simple::HTTP::Driver::Default
 
     # execute request
     net_http = load_net_http(uri.scheme, uri.host, uri.port)
-    resp = net_http.request(net_request)
+    response = net_http.request(net_request)
 
-    ::Simple::HTTP::Response.new status: Integer(resp.code),
-                                 message: resp.message,
-                                 headers: Simple::HTTP::Headers.new(resp),
-                                 body: resp.body
+    {
+      status: Integer(response.code),
+      message: response.message,
+      headers: Simple::HTTP::Headers.new(response),
+      body: response.body
+    }
   end
 
   private
@@ -39,10 +42,11 @@ module Simple::HTTP::Driver::Default
     :PUT    =>  Net::HTTP::Put,
     :DELETE =>  Net::HTTP::Delete
   }.freeze #:nodoc:
+  # rubocop:enable Style/HashSyntax, Layout/AlignHash
 
   #
   # build a HTTP request object.
-  def build_request(method, uri, body, _headers, client:)
+  def build_request(method, uri, body, headers, client:)
     klass = REQUEST_CLASSES.fetch(method)
     request = klass.new(uri.request_uri)
 
@@ -52,21 +56,12 @@ module Simple::HTTP::Driver::Default
       request.basic_auth(*client.basic_auth)
     end
 
-    # set request headers
-    # unless headers && !headers.empty?
-    #   # TODO: set headers
-    #   # set_request_headers request, headers
-    # end
-
-    # set request body
-    if request.request_body_permitted? && body
-      request.content_type = "application/json"
-      if body.is_a?(Hash) || body.is_a?(Array)
-        body = JSON.generate(body)
-      end
-      request.body = body
+    if headers && !headers.empty?
+      headers.each { |key, value| request[key] = value }
     end
 
+    request.body = body if body
+
     request
   end
 

data/lib/simple/http/driver/faraday.rb

@@ -0,0 +1,44 @@
+# rubocop:disable Metrics/AbcSize
+
+module Simple::HTTP::Driver
+end
+
+module Simple::HTTP::Driver::Faraday
+  extend self
+
+  URI_KLASSES = {
+    "http" => URI::HTTP,
+    "https" => URI::HTTPS
+  }
+
+  # does an HTTP request and returns its response.
+  def execute_request(request, client:)
+    connection = build_connection(request.url, client: client)
+
+    headers = request.headers.dup
+
+    body = request.body
+
+    resp = connection.run_request(request.verb.downcase, request.url, body, headers)
+
+    {
+      status: Integer(resp.status),
+      message: resp.reason_phrase,
+      headers: Simple::HTTP::Headers.new(resp.headers.to_hash),
+      body: resp.body
+    }
+  end
+
+  private
+
+  def build_connection(url, client:)
+    ::Faraday.new.tap do |connection|
+      uri = URI.parse(url)
+      if uri.user
+        connection.basic_auth(uri.user, uri.password)
+      elsif client.basic_auth
+        connection.basic_auth(*client.basic_auth)
+      end
+    end
+  end
+end

data/lib/simple/http/errors.rb

@@ -22,14 +22,32 @@ class Simple::HTTP::Error < RuntimeError
   end
 
   def verb
-    request.class::METHOD
+    request.verb
   end
 
   def message
-    "#{verb} #{request.uri} ##{status} #{response.message}"
+    "#{verb} #{request.url} ##{status} #{response.message}"
   end
 end
 
+class Simple::HTTP::StatusError < Simple::HTTP::Error
+  def self.raise(response:)
+    error_klass = case response.status
+                  when 400..499 then ::Simple::HTTP::Status4XXError
+                  when 500..599 then ::Simple::HTTP::Status5XXError
+                  else ::Simple::HTTP::StatusError
+    end
+
+    Kernel.raise error_klass.new(response)
+  end
+end
+
+class Simple::HTTP::Status4XXError < Simple::HTTP::StatusError
+end
+
+class Simple::HTTP::Status5XXError < Simple::HTTP::StatusError
+end
+
 class Simple::HTTP::TooManyRedirections < Simple::HTTP::Error
   def location
     response["Location"]

data/lib/simple/http/helpers.rb

@@ -0,0 +1,24 @@
+module Simple::HTTP::Helpers
+  module BuildURL
+    def build_url(base, *args)
+      option_args, string_args = args.partition { |arg| arg.is_a?(Hash) }
+      options = option_args.inject({}) { |hsh, option| hsh.update option }
+
+      url = File.join([base] + string_args)
+
+      query = build_query(options)
+      url += url.index("?") ? "&#{query}" : "?#{query}" if query
+
+      url
+    end
+
+    private
+
+    def build_query(params)
+      params = params.reject { |_k, v| v.blank? }
+      return nil if params.blank?
+
+      params.map { |k, value| "#{k}=#{escape(value.to_s)}" }.join("&")
+    end
+  end
+end

data/lib/simple/http/logger.rb

@@ -0,0 +1,8 @@
+require "logger"
+
+class Simple::HTTP
+  class << self
+    attr_accessor :logger
+  end
+  self.logger = Logger.new(STDERR, level: :warn)
+end

data/lib/simple/http/request.rb

@@ -1,10 +1,38 @@
 class Simple::HTTP::Request
   attr_reader :verb, :url, :body, :headers
 
-  def initialize(verb:, url:, body: nil, headers:)
+  class << self
+    def build(verb:, url:, body: nil, headers:)
+      if body_permitted?(verb) && !headers.key?("Content-Type")
+        if body.is_a?(Hash) || body.is_a?(Array)
+          headers["Content-Type"] = "application/json"
+          body = JSON.generate(body)
+        end
+      end
+
+      new verb, url, body, headers
+    end
+
+    private
+
+    def body_permitted?(verb)
+      return false if verb == :GET
+      return false if verb == :HEAD
+      return false if verb == :DELETE
+      return false if verb == :OPTIONS
+
+      true
+    end
+  end
+
+  private
+
+  def initialize(verb, url, body, headers)
     @verb, @url, @body, @headers = verb, url, body, headers
   end
 
+  public
+
   def to_s
     scrubbed_url = url.gsub(/\/\/(.*):(.*)@/) { |_| "//#{$1}:xxxxxx@" }
     "#{verb} #{scrubbed_url}"

data/lib/simple/http/response.rb

@@ -1,6 +1,23 @@
 require_relative "./body_builder"
 
 class Simple::HTTP::Response
+  class << self
+    def build(request:, body:, headers:, status:, message:)
+      unless body_permitted?(request.verb)
+        body = nil
+      end
+
+      new request, body, headers, status, message
+    end
+
+    def body_permitted?(verb)
+      return false if verb == :HEAD
+      return false if verb == :OPTIONS
+
+      true
+    end
+  end
+
   BodyBuilder = Simple::HTTP::BodyBuilder
 
   attr_reader :request
@@ -9,7 +26,10 @@ class Simple::HTTP::Response
   attr_reader :headers
   attr_reader :original_body
 
-  def initialize(body:, headers:, status:, message:)
+  private
+
+  def initialize(request, body, headers, status, message)
+    @request = request
     @headers = headers
     @status = status
     @message = message
@@ -23,12 +43,6 @@ class Simple::HTTP::Response
     end
   end
 
-  private
-
-  def set_request(request)
-    @request = request
-  end
-
   public
 
   # e.g "text/plain"
@@ -45,28 +59,58 @@ class Simple::HTTP::Response
   end
 
   def bytes
-    @original_body&.byte_size || 0
+    @original_body&.bytesize || 0
   end
 
   def to_s
     "#{status} #{message.gsub(/\s+$/, "")} (#{bytes} byte)"
   end
 
-  # evaluate and potentially parses response body.
-  # raises an Simple::Http::Error if the result code is not a 2xx
-  def content!
-    raise Error, self unless status >= 200 && status <= 299
+  # evaluate and potentially parse response
+  def content(into: nil)
+    return parsed_content if into.nil?
 
-    content
+    if parsed_content.is_a?(Array)
+      parsed_content.map { |entry| into.new entry }
+    else
+      into.new parsed_content
+    end
   end
 
-  # evaluate and potentially parse response
-  def content
-    case media_type
-    when "application/json"
-      JSON.parse(body) unless body.empty?
-    else
-      body
+  private
+
+  def parsed_content
+    return @parsed_content if defined? @parsed_content
+
+    @parsed_content = case media_type
+                      when "application/json"
+                        body.empty? ? nil : JSON.parse(body)
+                      else
+                        body
     end
   end
+
+  public
+
+  def checked_content(into:)
+    check_response_status!
+    content(into: into)
+  end
+
+  private
+
+  SUCCESSFUL_STATUS_CODES = 200..299
+
+  def check_response_status!
+    return if SUCCESSFUL_STATUS_CODES.include?(status)
+
+    Simple::HTTP.logger.warn do
+      msg = "#{request}: HTTP request failed w/#{self}"
+      msg += "\nheaders: #{headers}" if Simple::HTTP.logger.debug?
+      msg += "\nresponse body: #{body}" if body && Simple::HTTP.logger.info?
+      msg
+    end
+
+    ::Simple::HTTP::StatusError.raise(response: self)
+  end
 end

data/test/test_helper.rb

@@ -32,8 +32,9 @@ class Simple::HTTP::TestCase < Test::Unit::TestCase
 
     # The command to start the server must reset the BUNDLE_GEMFILE environment
     # setting.
-    command = "cd ../simple-httpd/ && BUNDLE_GEMFILE= PORT=12345 bin/simple-httpd #{httpd_root} -q" 
-    command = "#{command} 2> log/simple-httpd.log" 
+    # command = "cd ../simple-httpd/ && BUNDLE_GEMFILE= PORT=12345 bin/simple-httpd start #{httpd_root} -q" 
+    command = "PORT=12345 bundle exec simple-httpd start #{httpd_root}" 
+    command = "#{command} -q 2> log/simple-httpd.log" 
 
     ::RSpec::Httpd::Server.start! port: PORT, command: command
   end

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: simple-http
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - radiospiel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-29 00:00:00.000000000 Z
-dependencies: []
+date: 2019-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: expectation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
 description: Simple code for simple HTTP requests
 email: eno@radiospiel.org
 executables: []
@@ -21,9 +41,13 @@ files:
 - lib/simple/http.rb
 - lib/simple/http/body_builder.rb
 - lib/simple/http/caching.rb
+- lib/simple/http/checked_response.rb
 - lib/simple/http/driver/default.rb
+- lib/simple/http/driver/faraday.rb
 - lib/simple/http/errors.rb
 - lib/simple/http/headers.rb
+- lib/simple/http/helpers.rb
+- lib/simple/http/logger.rb
 - lib/simple/http/request.rb
 - lib/simple/http/response.rb
 - lib/simple/http/version.rb
@@ -54,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Simple code for simple HTTP requests