rb-net_http-client 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 864953a6821c8556cd571a116d852aadb39810fbe41c672ce4a4d0a9d37ad0cc
-  data.tar.gz: 53fbde8821ae8c0610dc7ad7b1b798b92728df13fc05fd1bad0ca620dfb61761
+  metadata.gz: 5d6b584195ee54303f03e597cedf0863b804496d00fe7dc23e1c95a72685d27e
+  data.tar.gz: bd2031391105c97823c38fe5422b497617e50bcbe77d0fe82138b191a6a8dd6f
 SHA512:
-  metadata.gz: fecbe20848e6f55335b16cbe3d5a8f418a1b5843a69aac09fa9f068eb67ccb08c407ca3226357c4595d9e2ccb60454b6e06357b6c7fba109d297098ffba47d7b
-  data.tar.gz: 7d5ffbc523f9c97bc3e241c7ca41f117f2ba51849d69b540c0e4ad5d5f8d30a221a4c09012812ab95d8c029c61ff030b8042eb2d46d175c028a1c638fb4ab2eb
+  metadata.gz: 3a1d80d3519cdd9b8ba725906ae951c70f70ed67a5f992650e66b0b3d31707eecc1608a03a241cb6c15aaf683e2ca7be4dcf814bdc7284aec53d16d2097b3617
+  data.tar.gz: 1519c8ecfaa3075ffa1db0ede1467c0b465c851464c721c118d25516656ff2abc63c67f3448fbdc5a23f3d668efe04d1ef660cf078cb4ab6546fa33fcc8c7b50

data/lib/client/client.rb

@@ -12,19 +12,18 @@ module NetHTTP
     attr_reader :ca_file,
                 :cert,
                 :client,
-                :host,
                 :key,
                 :logger,
-                :path,
+                :open_timeout,
                 :pkcs12,
-                :port,
                 :proxy_uri,
-                :open_timeout,
+                :proxy_url,
+                :query,
                 :read_timeout,
                 :response,
-                :scheme,
                 :ssl_path,
                 :uri,
+                :url,
                 :use_proxy,
                 :use_ssl,
                 :verify_mode
@@ -32,19 +31,14 @@ module NetHTTP
     def initialize(opts = {})
       send('logger=', opts[:logger])
       Core.schema_validation(opts, NetHTTP::Client::Schema, logger) unless opts[:enforce_schema_validation] == false
-      send('uri=', (opts[:uri] || opts[:url]))
+      send('uri=', opts)
       send('client=', opts)
     end
 
     def client=(opts = {})
       @client = Net::HTTP.new(uri.host, uri.port)
 
-      send('scheme=', uri.scheme)
-      send('host=', uri.host)
-      send('port=', uri.port)
-      send('path=', uri.path)
-      send('proxy_uri=', (opts[:proxy_uri] ||= opts[:proxy_url]))
-      send('use_proxy=')
+      send('proxy_uri=', opts)
       send('open_timeout=', (opts[:open_timeout] ||= 60))
       send('read_timeout=', (opts[:read_timeout] ||= 60))
       send('use_ssl=', opts[:use_ssl], uri.scheme)
@@ -68,12 +62,14 @@ module NetHTTP
       end
     end
 
-    private :logger,
-            :response
+    private :response
 
     def logger=(logger = nil)
       @logger = Core.get_logger(logger)
     end
+
+    alias proxy_url proxy_uri
+    alias url uri
   end
 
   module_function

data/lib/client/ext.rb

@@ -2,40 +2,48 @@
 
 module NetHTTP
   class Client
-    def scheme=(scheme = nil)
-      @scheme = scheme
-    end
-
-    def host=(host = nil)
-      @host = host
-    end
-
-    def port=(port = nil)
-      @port = port
-    end
-
-    def path=(path = nil)
-      @path = path
-    end
-
-    def use_proxy=
-      if proxy_uri.nil?
-        @use_proxy = false
-      else
-        @use_proxy = true
+    def proxy_uri=(opts = {})
+      proxy_uri = opts[:proxy_uri] ||= opts[:proxy_url] ||= ENV['http_proxy'] ||= ENV['HTTP_PROXY'] ||= ENV['https_proxy'] ||= ENV['HTTPS_PROXY']
+
+      begin
+        if proxy_uri.to_s.empty? == false
+          @proxy_uri = Core::Utilities.parse_uri(proxy_uri)
+        else
+          @proxy_uri = Core::Utilities.parse_uri(
+            Core::Utilities.construct_uri(
+              scheme: opts[:proxy_uri_scheme],
+              host: opts[:proxy_uri_host],
+              port: opts[:proxy_uri_port],
+              path: opts[:proxy_uri_path],
+              query: opts[:proxy_uri_query]
+            )
+          )
+        end
+      rescue RuntimeError => error
+        logger.debug(error)
+        @proxy_uri = nil
       end
     end
 
-    def proxy_uri=(proxy_uri = nil)
-      proxy_uri = ENV['http_proxy'] ||= ENV['HTTP_PROXY'] ||= ENV['https_proxy'] ||= ENV['HTTPS_PROXY'] if proxy_uri.nil?
-      @proxy_uri = Core::Utilities.parse_uri(proxy_uri)
-    end
-
-    def uri=(uri = nil)
-      if !uri.nil?
-        @uri = Core::Utilities.parse_uri(uri)
-      else
-        @uri = Core::Utilities.parse_uri(Core::Utilities.construct_uri(opts[:scheme], opts[:host], opts[:port], opts[:path]))
+    def uri=(opts = {})
+      uri = opts[:uri] ||= opts[:url]
+      begin
+        if uri.to_s.empty? == false
+          @uri = Core::Utilities.parse_uri(uri)
+        else
+          @uri = Core::Utilities.parse_uri(
+            Core::Utilities.construct_uri(
+              scheme: opts[:scheme],
+              host: opts[:host],
+              port: opts[:port],
+              path: opts[:path],
+              query: opts[:query]
+            )
+          )
+        end
+      rescue RuntimeError => error
+        logger.debug(error)
+        @uri = nil
       end
     end
 

data/lib/client/schema.rb

@@ -6,24 +6,37 @@ module NetHTTP
   class Client
     Schema = Dry::Validation.Schema do
       configure do
+        def name
+          'NetHTTP::Client::Schema'
+        end
+
         def true_or_false
           [true, false]
         end
       end
 
-      optional(:logger).filled
-      optional(:uri).maybe(type?: String)
-      optional(:url).maybe(type?: String)
-      optional(:scheme).maybe(type?: String)
+      optional(:ca_file).filled(type?: String)
       optional(:host).maybe(type?: String)
-      optional(:port).maybe(type?: Integer)
+      optional(:logger).filled
+      optional(:open_timeout).filled(type?: Integer)
       optional(:path).maybe(type?: String)
+      optional(:port).maybe(type?: Integer)
+      optional(:pkcs12_file).filled(type?: String)
+      optional(:pkcs12_passphrase).filled(type?: String)
+      optional(:proxy_uri_host).maybe(type?: String)
+      optional(:proxy_uri_path).maybe(type?: String)
+      optional(:proxy_uri_port).maybe(type?: Integer)
+      optional(:proxy_uri_scheme).maybe(type?: String)
       optional(:proxy_uri).filled(type?: String)
       optional(:proxy_url).filled(type?: String)
-      optional(:use_proxy).filled(included_in?: true_or_false)
-      optional(:use_ssl).filled(included_in?: true_or_false)
-      optional(:open_timeout).filled(type?: Integer)
+      optional(:query).filled(type?: String)
       optional(:read_timeout).filled(type?: Integer)
+      optional(:scheme).maybe(type?: String)
+      optional(:ssl_path).filled(type?: String)
+      optional(:uri).maybe(type?: String)
+      optional(:url).maybe(type?: String)
+      optional(:use_ssl).filled(included_in?: true_or_false)
+      optional(:verify_mode).filled
 
       rule(if_url_and_uri_are_nil_must_provide_host: [:uri, :url, :host]) do |uri, url, host|
         uri.empty?.then(url.empty?.then(host.filled?))

data/lib/core/core.rb

@@ -16,11 +16,22 @@ module NetHTTP
     end
 
     def self.schema_validation(opts, schema, logger)
-      results = schema.call(opts)
-      return if results.success?
-
-      logger.debug("NetHTTP::Core::SchemaValidationError - #{schema} input validation failed due to => #{results.messages}")
-      raise "NetHTTP::Core::SchemaValidationError - #{schema} input validation failed."
+      begin
+        results = schema.call(opts)
+        return if results.success?
+        begin
+          schema_name = schema.name
+          logger.debug("NetHTTP::Core::SchemaValidationError - #{schema_name} input validation failed due to => #{results.messages}")
+          raise("NetHTTP::Core::SchemaValidationError - #{schema_name} input validation failed due to => #{results.messages}")
+        rescue RuntimeError => error
+          logger.debug("NetHTTP::Core::SchemaValidationError - Dry::Validation::Schema input validation failed due to => #{results.messages}")
+          raise("NetHTTP::Core::SchemaValidationError - Dry::Validation::Schema input validation failed due to => #{results.messages}")
+        end
+      rescue RuntimeError => error
+        logger.debug(error)
+        logger.debug("NetHTTP::Core::SchemaValidationError - Dry::Validation::Schema input validation failed.")
+        raise error
+      end
     end
   end
 end

data/lib/core/utilities.rb

@@ -9,38 +9,55 @@ module NetHTTP
   class Core
     class Utilities
       def self.construct_uri(uri = {})
-        return nil if uri[:host].nil?
-
-        scheme = case uri[:scheme]
-                 when 'http', 'https'
-                   "#{uri[:scheme]}://"
-                 end
-        port = if uri[:port].nil? || uri[:port].to_s.empty?
-                 nil
-               else
-                 ":#{uri[:port].to_i}"
-               end
-        "#{scheme}#{host}#{port}#{path}"
+        return nil if uri.empty?
+        return nil if uri[:host].to_s.empty?
+        return nil if uri[:scheme].to_s.empty? && uri[:port].to_s.empty?
+
+        scheme = uri[:scheme]
+        if scheme.to_s.empty?
+          case uri[:port]
+          when 80, '80'
+            scheme = 'http'
+          else
+            scheme = 'https'
+          end
+        end
+
+        port = uri[:port]
+        if port.to_s.empty?
+          case uri[:scheme]
+          when 'https'
+            port = 443
+          when 'http'
+            port = 80
+          end
+        end
+
+        scheme = "#{scheme}://"
+        host = uri[:host]
+        port = ":#{port}"
+        path = uri[:path]
+        query = "?#{uri[:query]}"
+
+        scheme = nil if scheme.to_s.empty?
+        port = nil if port.to_s.empty?
+        path = nil if uri[:path].to_s.empty?
+        query = nil if uri[:query].to_s.empty?
+
+        URI("#{scheme}#{host}#{port}#{path}#{query}").to_s
       end
 
       def self.parse_uri(uri)
         return if uri.nil?
         return if uri.to_s.empty?
 
-        parsed_uri = URI(uri)
-
-        scheme = parsed_uri.to_s.scan(%r{(https|http):\/\/}).flatten[0]
-        port = parsed_uri.to_s.scan(%r{:(\d+)\/}).flatten[0] ||= parsed_uri.port
+        scheme = uri.to_s.scan(%r{([a-z][a-z0-9+\-.]*)://}).flatten[0].to_s
+        return URI(uri) if scheme.downcase == 'http'
+        return URI(uri) if scheme.downcase == 'https'
 
-        return URI(parsed_uri) if scheme == 'http'
-        return URI(parsed_uri) if scheme == 'https'
-
-        case port
-        when 80, '80'
-          URI("http://#{parsed_uri.to_s.gsub("#{scheme}://", '')}")
-        else
-          URI("https://#{parsed_uri.to_s.gsub("#{scheme}://", '')}")
-        end
+        port = uri.to_s.scan(%r{:([0-9]+)}).flatten[0].to_s
+        return URI("http://#{uri.to_s.gsub("#{scheme}://", '')}") if port == '80'
+        URI("https://#{uri.to_s.gsub("#{scheme}://", '')}")
       end
 
       # CamelCase to snake_case
@@ -128,8 +145,8 @@ module NetHTTP
             format: 'snake',
             type: type.downcase
           )
-        rescue RuntimeError => err
-          raise err
+        rescue RuntimeError => error
+          raise error
         end
       end
 
@@ -152,8 +169,8 @@ module NetHTTP
             format: 'snake',
             type: type.downcase
           )
-        rescue RuntimeError => err
-          raise err
+        rescue RuntimeError => error
+          raise error
         end
       end
 
@@ -196,8 +213,8 @@ module NetHTTP
             format: 'snake',
             type: type.downcase
           )
-        rescue RuntimeError => err
-          raise err
+        rescue RuntimeError => error
+          raise error
         end
       end
 
@@ -207,13 +224,13 @@ module NetHTTP
           return false if json_doc.empty?
 
           JSON.parse(json_doc)
-        rescue JSON::ParserError => err
+        rescue JSON::ParserError => error
           if logger.nil? || logger.to_s.empty?
             puts 'WARNING - JSON syntax / parsing errors detected:'
-            puts err
+            puts error
           else
             logger.debug('WARNING - JSON syntax / parsing errors detected:')
-            logger.debug(err)
+            logger.debug(error)
           end
           return false
         end
@@ -253,9 +270,12 @@ module NetHTTP
           return false unless html_doc.include?('<body>')
           return false unless html_doc.include?('</body>')
           return false unless Nokogiri::HTML(html_doc).errors.empty?
+          return false unless Nokogiri::XML(html_doc).errors.empty?
 
           begin
-            parse_errors = Nokogiri::HTML.parse(html_doc).validate
+            # parse_errors = Nokogiri::HTML.parse(html_doc).validate
+            parse_errors = Nokogiri::XML(html_doc).errors { |c| c.options = Nokogiri::XML::ParseOptions::STRICT }
+            Nokogiri::XML(html_doc) { |c| c.options = Nokogiri::XML::ParseOptions::STRICT }
           rescue Nokogiri::XML::SyntaxError
             if logger.nil? || logger.to_s.empty?
               puts 'WARNING - HTML syntax / parsing errors detected:'
@@ -266,8 +286,8 @@ module NetHTTP
             end
             return true
           end
-        rescue RuntimeError => err
-          raise err
+        rescue RuntimeError => error
+          raise error
         end
 
         true

data/lib/request/request.rb

@@ -2,6 +2,7 @@
 
 require_relative 'schema'
 require_relative '../core/core'
+require_relative '../response/response'
 
 module NetHTTP
   class Client
@@ -30,11 +31,11 @@ module NetHTTP
 
       opts[:method] = 'delete'
       request_opts = request_opts(opts)
-      logger.debug('Request Method => ' + request_opts[:method])
-      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + request_opts[:uri].host.to_s)
+      logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
+      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
       logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
       logger.debug('Request Path => ' + request_opts[:path])
-      Response.new(
+      NetHTTP::Response.new(
         response: client.delete(
           request_opts[:path]
         ),
@@ -47,13 +48,13 @@ module NetHTTP
 
       opts[:method] = 'get'
       request_opts = request_opts(opts)
-      logger.debug('Request Method => ' + request_opts[:method])
-      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + request_opts[:uri].host.to_s)
+      logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
+      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
       logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
       logger.debug('Request Path => ' + request_opts[:path])
       logger.debug('Request Headers =>')
       logger.debug(request_opts[:headers])
-      Response.new(
+      NetHTTP::Response.new(
         response: client.get(
           request_opts[:path],
           request_opts[:headers]
@@ -67,15 +68,15 @@ module NetHTTP
 
       opts[:method] = 'post'
       request_opts = request_opts(opts)
-      logger.debug('Request Method => ' + request_opts[:method])
-      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + request_opts[:uri].host.to_s)
+      logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
+      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
       logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
       logger.debug('Request Path => ' + request_opts[:path])
       logger.debug('Request Headers =>')
       logger.debug(request_opts[:headers])
       logger.debug('Request Body =>')
       logger.debug(request_opts[:body])
-      Response.new(
+      NetHTTP::Response.new(
         response: client.post(
           request_opts[:path],
           request_opts[:body],
@@ -90,15 +91,15 @@ module NetHTTP
 
       opts[:method] = 'post_form'
       request_opts = request_opts(opts)
-      logger.debug('Request Method => ' + request_opts[:method])
-      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + request_opts[:uri].host.to_s)
+      logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
+      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
       logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
       logger.debug('Request Path => ' + request_opts[:path])
       logger.debug('Request Headers =>')
       logger.debug(request_opts[:headers])
       logger.debug('Request Body =>')
       logger.debug(URI.encode_www_form(request_opts[:body]))
-      Response.new(
+      NetHTTP::Response.new(
         response: client.post(
           uri,
           URI.encode_www_form(request_opts[:body]),
@@ -115,15 +116,15 @@ module NetHTTP
 
       opts[:method] = 'put'
       request_opts = request_opts(opts)
-      logger.debug('Request Method => ' + request_opts[:method])
-      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + request_opts[:uri].host.to_s)
+      logger.debug('Request Method => ' + request_opts[:method].to_s.upcase)
+      logger.debug('Request Host => ' + request_opts[:uri].scheme.to_s + '://' + request_opts[:uri].host.to_s)
       logger.debug('Request Port => ' + request_opts[:uri].port.to_s)
       logger.debug('Request Path => ' + request_opts[:path])
       logger.debug('Request Headers =>')
       logger.debug(request_opts[:headers])
       logger.debug('Request Body =>')
       logger.debug(request_opts[:body])
-      Response.new(
+      NetHTTP::Response.new(
         response: client.put(
           request_opts[:path],
           request_opts[:body],
@@ -133,17 +134,43 @@ module NetHTTP
       )
     end
 
-    def request_opts(opts = {})
+    def request_opts(opts)
       Core.schema_validation(opts, NetHTTP::Request::Schema, logger) unless opts[:enforce_schema_validation] == false
 
-      request_opts = {}
-      request_opts[:method] = opts[:method] ||= 'post'
-      request_opts[:uri] = opts[:uri] ||= opts[:url] ||= uri
-      request_opts[:path] = opts[:path] ||= request_opts[:uri].path ||= path
-      request_opts[:path] = (request_opts[:path] + '?' + request_opts[:uri].query) unless request_opts[:uri].query.nil? || request_opts[:path].include?('?')
-      request_opts[:headers] = opts[:headers] ||= {}
-      request_opts[:body] = opts[:body] ||= nil
-      request_opts
+      request_method = opts[:method] ||= 'post'
+      request_uri = Core::Utilities.parse_uri(opts[:uri] || opts[:url] || uri)
+      request_path = request_path(
+        path: (opts[:path] || request_uri.path || path),
+        query: (opts[:query] || request_uri.query || query)
+      )
+      request_headers = opts[:headers] ||= {}
+      request_body = opts[:body] ||= nil
+
+      {
+        method: request_method,
+        uri: request_uri,
+        path: request_path,
+        headers: request_headers,
+        body: request_body
+      }
+    end
+
+    def request_path(opts)
+      # i.e. URI('https://www.google.com')
+      # uri.path defaults to "" if empty / not set
+      # uri.query defaults to nil if empty / not set
+      path = opts[:path].to_s.chomp('?')
+      if opts[:query].to_s.start_with?('?')
+        query = opts[:query][1..-1]
+      else
+        query = opts[:query].to_s
+      end
+
+      return '' if path.empty? && query.empty?
+      return path if query.empty?
+      return '/' + query if path.empty?
+
+      path + '?' + query
     end
   end
 end

data/lib/request/schema.rb

@@ -5,9 +5,16 @@ require 'dry-validation'
 module NetHTTP
   class Request
     Schema = Dry::Validation.Schema do
+      configure do
+        def name
+          'NetHTTP::Request::Schema'
+        end
+      end
+
       required(:method).filled(type?: String)
       optional(:headers).maybe(type?: Hash)
       optional(:body).maybe
+      optional(:query).filled(type?: String)
 
       rule(if_url_and_uri_are_nil_must_provide_path: [:uri, :url, :path]) do |uri, url, path|
         uri.empty?.then(url.empty?.then(path.filled?))