rb-net_http-client 0.0.4 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43106fa08999d370c0d5d28bdf9dc5ce1fecd7ecb32b72ee96d7b12ed63a7259
-  data.tar.gz: 773fba38a078d87ab259dfa8c7a575d68e4cf2307dfed0d7affbacbb09dd2040
+  metadata.gz: 864953a6821c8556cd571a116d852aadb39810fbe41c672ce4a4d0a9d37ad0cc
+  data.tar.gz: 53fbde8821ae8c0610dc7ad7b1b798b92728df13fc05fd1bad0ca620dfb61761
 SHA512:
-  metadata.gz: e7867815e0b13eefc9b15d35ab29af789879849f8d2d3eca4853cd273e5196764b2cd849a8ec0ff32ddb29b6b33712d76d1a5c80ee9db93ddb413e7ce3c58f22
-  data.tar.gz: d278c746b537012f7767f429a1554059db30771ee9348dd7acbabd1620ff6a5c8f074a3771e1bd6ead4cd3e24583ce499334f52cda924e28603f8cd024f911f8
+  metadata.gz: fecbe20848e6f55335b16cbe3d5a8f418a1b5843a69aac09fa9f068eb67ccb08c407ca3226357c4595d9e2ccb60454b6e06357b6c7fba109d297098ffba47d7b
+  data.tar.gz: 7d5ffbc523f9c97bc3e241c7ca41f117f2ba51849d69b540c0e4ad5d5f8d30a221a4c09012812ab95d8c029c61ff030b8042eb2d46d175c028a1c638fb4ab2eb

data/lib/client/client.rb

@@ -4,48 +4,81 @@ require 'net/https'
 require_relative 'ext'
 require_relative 'schema'
 require_relative '../core/core'
-require_relative '../request/ext'
-require_relative '../response/ext'
+require_relative '../response/response'
+require_relative '../request/request'
 
 module NetHTTP
-  module_function
+  class Client
+    attr_reader :ca_file,
+                :cert,
+                :client,
+                :host,
+                :key,
+                :logger,
+                :path,
+                :pkcs12,
+                :port,
+                :proxy_uri,
+                :open_timeout,
+                :read_timeout,
+                :response,
+                :scheme,
+                :ssl_path,
+                :uri,
+                :use_proxy,
+                :use_ssl,
+                :verify_mode
+
+    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('client=', opts)
+    end
 
-  def client(opts)
-    logger = Core.assign_logger(opts[:logger])
+    def client=(opts = {})
+      @client = Net::HTTP.new(uri.host, uri.port)
 
-    Core.schema_validation(opts, NetHTTP::Client::Schema, logger) unless opts[:enforce_schema_validation] == false
+      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('open_timeout=', (opts[:open_timeout] ||= 60))
+      send('read_timeout=', (opts[:read_timeout] ||= 60))
+      send('use_ssl=', opts[:use_ssl], uri.scheme)
+      send('ssl_path=', opts[:ssl_path])
+      send('pkcs12_file=', opts[:pkcs12_file])
+      send('pkcs12_passphrase=', opts[:pkcs12_passphrase])
+      send('pkcs12=')
+      send('cert=')
+      send('key=')
+      send('ca_file=', opts[:ca_file])
+      send('verify_mode=', opts[:verify_mode])
 
-    if !(opts[:uri] ||= opts[:url] ||= nil).nil?
-      uri = Core.parse_uri((opts[:uri] ||= opts[:url]))
-    else
-      uri = Core.parse_uri(Core.construct_uri(opts[:scheme], opts[:host], opts[:port], opts[:path]))
+      @client.open_timeout = open_timeout
+      @client.read_timeout = read_timeout
+      @client.use_ssl = use_ssl
+      if use_ssl
+        @client.cert = cert
+        @client.key = key
+        @client.ca_file = ca_file
+        @client.verify_mode = verify_mode
+      end
     end
 
-    # Instantiate client:
-    client = Net::HTTP.new(uri.host, uri.port)
-
-    # client config:
-    client.logger = logger
-    client.uri = uri
-    client.host = uri.host
-    client.port = uri.port
-    client.path = uri.path
-    client.use_proxy = Client.use_proxy(opts[:use_proxy])
-    client.proxy_uri = Client.proxy_uri((opts[:proxy_uri] ||= opts[:proxy_url]), client.use_proxy)
-    client.open_timeout = Client.open_timeout(opts[:open_timeout])
-    client.read_timeout = Client.read_timeout(opts[:read_timeout])
-
-    # SSL config:
-    client.use_ssl = Client.use_ssl(opts[:use_ssl], uri.scheme)
-
-    if client.use_ssl
-      pkcs12 = Client.pkcs12(opts[:ssl_path], opts[:pkcs12_file], opts[:pkcs12_passphrase])
-      client.cert = Client.cert(pkcs12)
-      client.key = Client.key(pkcs12)
-      client.ca_file = Client.ca_file(opts[:ssl_path], opts[:ca_file])
-      client.verify_mode = Client.verify_mode(opts[:verify_mode])
+    private :logger,
+            :response
+
+    def logger=(logger = nil)
+      @logger = Core.get_logger(logger)
     end
+  end
+
+  module_function
 
-    client
+  def client(opts = {})
+    Client.new(opts)
   end
 end

data/lib/client/ext.rb

@@ -1,120 +1,137 @@
 # frozen_string_literal: true
 
-require_relative '../core/core'
-
 module NetHTTP
-  module Client
-    module_function
-
-    def proxy_uri(proxy_uri, use_proxy)
-      return nil if use_proxy == false
+  class Client
+    def scheme=(scheme = nil)
+      @scheme = scheme
+    end
 
-      Core.parse_uri(proxy_uri ||= ENV['http_proxy'] ||= ENV['HTTP_PROXY'] ||= ENV['https_proxy'] ||= ENV['HTTPS_PROXY'])
+    def host=(host = nil)
+      @host = host
     end
 
-    def use_proxy(use_proxy)
-      return false if use_proxy == false
+    def port=(port = nil)
+      @port = port
+    end
 
-      true
+    def path=(path = nil)
+      @path = path
     end
 
-    def use_ssl(use_ssl, scheme)
-      if use_ssl.nil? || use_ssl.to_s.empty?
-        return false if scheme == 'http'
-        return true if scheme == 'https'
+    def use_proxy=
+      if proxy_uri.nil?
+        @use_proxy = false
+      else
+        @use_proxy = true
       end
-      return false if use_ssl == false
-
-      true
     end
 
-    def open_timeout(open_timeout)
-      (open_timeout ||= 60).to_s.to_i
+    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 read_timeout(read_timeout)
-      (read_timeout ||= 60).to_s.to_i
+    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]))
+      end
     end
 
-    def pkcs12(ssl_path, pkcs12_file, pkcs12_passphrase)
-      return nil if ssl_path.nil?
-      return nil if ssl_path.to_s.empty?
-      return nil if pkcs12_file.nil?
-      return nil if pkcs12_file.to_s.empty?
-      return nil if pkcs12_passphrase.nil?
-      return nil if pkcs12_passphrase.to_s.empty?
-
-      OpenSSL::PKCS12.new(File.binread(ssl_path + '/' + pkcs12_file), pkcs12_passphrase)
+    def ca_file=(ca_file)
+      if ca_file.nil? || ca_file.to_s.empty?
+        @ca_file = nil
+      elsif ssl_path.nil? || ssl_path.to_s.empty?
+        @ca_file = nil
+      else
+        @ca_file = File.binread(ssl_path + '/' + ca_file)
+      end
     end
 
-    def cert(pkcs12)
-      return nil if pkcs12.nil?
-      return nil if pkcs12.to_s.empty?
-
-      OpenSSL::X509::Certificate.new(pkcs12.certificate)
+    def cert=
+      if pkcs12.nil? || pkcs12.to_s.empty?
+        @cert = nil
+      else
+        @cert = OpenSSL::X509::Certificate.new(pkcs12.certificate)
+      end
     end
 
-    def key(pkcs12)
-      return nil if pkcs12.nil?
-      return nil if pkcs12.to_s.empty?
-
-      OpenSSL::PKey::RSA.new(pkcs12.key)
+    def key=
+      if pkcs12.nil? || pkcs12.to_s.empty?
+        @key = nil
+      else
+        @key = OpenSSL::PKey::RSA.new(pkcs12.key)
+      end
     end
 
-    def ca_file(ssl_path, ca_file)
-      return nil if ssl_path.nil?
-      return nil if ssl_path.to_s.empty?
-      return nil if ca_file.nil?
-      return nil if ca_file.to_s.empty?
+    def open_timeout=(open_timeout)
+      @open_timeout = open_timeout.to_s.to_i
+    end
 
-      File.binread(ssl_path + '/' + ca_file)
+    def pkcs12=
+      if ssl_path.nil? || ssl_path.to_s.empty?
+        @pkcs12 = nil
+      elsif pkcs12_file.nil? || pkcs12_file.to_s.empty?
+        @pkcs12 = nil
+      elsif pkcs12_passphrase.nil? || pkcs12_passphrase.to_s.empty?
+        @pkcs12 = nil
+      else
+        OpenSSL::PKCS12.new(File.binread(ssl_path + '/' + pkcs12_file), pkcs12_passphrase)
+      end
     end
 
-    def verify_mode(verify_mode)
-      return OpenSSL::SSL::VERIFY_NONE if verify_mode.nil?
-      return OpenSSL::SSL::VERIFY_NONE if verify_mode.to_s.empty?
+    def pkcs12_file=(pkcs12_file)
+      if pkcs12_file.nil? || pkcs12_file.to_s.empty?
+        @pkcs12_file = nil
+      else
+        @pkcs12_file = pkcs12_file
+      end
+    end
 
-      verify_mode
+    def pkcs12_passphrase=(pkcs12_passphrase)
+      if pkcs12_passphrase.nil? || pkcs12_passphrase.to_s.empty?
+        @pkcs12_passphrase = nil
+      else
+        @pkcs12_passphrase = pkcs12_passphrase
+      end
     end
 
-    module Ext
-      # TODO: Define public / private
-      # Also look into module_function and how that impacts attr_reader / attr_writer
-      attr_reader :host,
-                  :path,
-                  :logger,
-                  :uri,
-                  :url,
-                  :use_proxy,
-                  :use_ssl
+    def read_timeout=(read_timeout)
+      @read_timeout = read_timeout.to_s.to_i
+    end
 
-      attr_writer :host,
-                  :port,
-                  :path,
-                  :logger,
-                  :uri,
-                  :url,
-                  :use_proxy,
-                  :use_ssl
+    def ssl_path=(ssl_path)
+      if ssl_path.nil? || ssl_path.to_s.empty?
+        @ssl_path = nil
+      else
+        @ssl_path = ssl_path
+      end
+    end
 
-      def proxy_uri=(proxy_uri)
-        if proxy_uri.class.ancestors.include? URI
-          @proxy_address = URI(proxy_uri)
-          @proxy_port = URI(proxy_uri).port
-          @proxy_uri = URI(proxy_uri)
-        else
-          @proxy_address = nil
-          @proxy_port = nil
-          @proxy_uri = nil
+    def use_ssl=(use_ssl, scheme)
+      @use_ssl = true
+      case use_ssl
+      when false
+        @use_ssl = false
+      when true
+        @use_ssl = true
+      else
+        case scheme.downcase
+        when 'http'
+          @use_ssl = false
+        when 'https'
+          @use_ssl = true
         end
       end
     end
-  end
-end
 
-module Net
-  class HTTP
-    include NetHTTP::Core
-    include NetHTTP::Client::Ext
+    def verify_mode=(verify_mode)
+      if verify_mode.nil? || verify_mode.to_s.empty?
+        @verify_mode = OpenSSL::SSL::VERIFY_NONE
+      else
+        @verify_mode = verify_mode
+      end
+    end
   end
 end

data/lib/client/schema.rb

@@ -3,7 +3,7 @@
 require 'dry-validation'
 
 module NetHTTP
-  module Client
+  class Client
     Schema = Dry::Validation.Schema do
       configure do
         def true_or_false

data/lib/core/core.rb

@@ -1,75 +1,26 @@
 # frozen_string_literal: true
 
 require 'logger'
-require 'nokogiri'
-require 'uri'
 
 module NetHTTP
-  module Core
-    def logger
-      @logger || send('logger=', nil)
-    end
-
-    def logger=(logger = nil)
-      @logger = assign_logger(logger)
-    end
-
-    module_function
-
-    def assign_logger(logger = nil)
+  class Core
+    def self.get_logger(logger = nil)
       return logger if logger.class == Logger
 
       if logger.nil? || logger.to_s.empty?
         logger = Logger.new(STDOUT)
         logger.level = Logger::INFO
       end
-      logger
-    end
-
-    def construct_uri(scheme, host, port, path)
-      return nil if host.nil?
-
-      uri_scheme = case scheme
-                   when 'http', 'https'
-                     "#{scheme}://"
-                   end
-      uri_port = if port.nil? || port.to_s.empty?
-                   nil
-                 else
-                   ":#{port.to_i}"
-                 end
-      "#{uri_scheme}#{host}#{uri_port}#{path}"
-    end
-
-    def 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
-
-      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
+      logger
     end
 
-    def schema_validation(opts, schema, logger = nil)
+    def self.schema_validation(opts, schema, logger)
       results = schema.call(opts)
       return if results.success?
 
-      if logger.nil? || logger.to_s.empty?
-      else
-        logger.debug("NetHTTP::Core::Error - schema input validation failed due to => #{results.messages}")
-      end
-      raise 'NetHTTP::Core::Error - schema input validation failed.'
+      logger.debug("NetHTTP::Core::SchemaValidationError - #{schema} input validation failed due to => #{results.messages}")
+      raise "NetHTTP::Core::SchemaValidationError - #{schema} input validation failed."
     end
   end
 end

data/lib/core/utilities.rb

@@ -2,15 +2,49 @@
 
 require 'json'
 require 'nokogiri'
+require 'uri'
 require 'yaml'
 
 module NetHTTP
-  module Core
-    module Utilities
-      module_function
+  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}"
+      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
+
+        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
+      end
 
       # CamelCase to snake_case
-      def camel_2_snake(key, type = nil)
+      def self.camel_2_snake(key, type = nil)
         new_key = key.to_s
                      .tr('::', '/')
                      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
@@ -29,7 +63,7 @@ module NetHTTP
       end
 
       # snake_case to CamelCase
-      def snake_2_camel(key, type = nil)
+      def self.snake_2_camel(key, type = nil)
         new_key = key.to_s.split('_')
         new_key = new_key[0].downcase + new_key[1..-1].map(&:capitalize).join('')
 
@@ -46,36 +80,36 @@ module NetHTTP
       # convert hash / array / nested object keys to either snake_case or CamelCase
       # format -> 'snake' or 'camel'
       # type -> 'string' or 'symbol'
-      def convert_hash_keys(request = {})
-        return request[:object] if request[:format].nil? && request[:type].nil?
+      def self.convert_hash_keys(opts = {})
+        return opts[:object] if opts[:format].nil? && opts[:type].nil?
 
-        case request[:object]
+        case opts[:object]
         when Hash
           new_hash = {}
-          request[:object].each do |key, value|
+          opts[:object].each do |key, value|
             value = convert_hash_keys(
               object: value,
-              format: request[:format],
-              type: request[:type]
+              format: opts[:format],
+              type: opts[:type]
             )
-            case request[:format].downcase
+            case opts[:format].downcase
             when 'snake'
-              new_key = camel_2_snake(key, request[:type])
+              new_key = camel_2_snake(key, opts[:type])
             when 'camel'
-              new_key = snake_2_camel(key, request[:type])
+              new_key = snake_2_camel(key, opts[:type])
             end
             new_hash[new_key] = value
           end
           return new_hash
         when Array
-          return request[:object].map { |value| convert_hash_keys(object: value, format: request[:format], type: request[:type]) }
+          return opts[:object].map { |value| convert_hash_keys(object: value, format: opts[:format], type: opts[:type]) }
         end
 
-        request[:object]
+        opts[:object]
       end
 
       # Convert JSON doc to a Ruby Hash.
-      def json_2_hash(json_doc, type = 'symbol', logger = nil)
+      def self.json_2_hash(json_doc, type = 'symbol', logger = nil)
         msg = "Invalid 'type' => #{type}.  Use either 'string' or 'symbol' (default)."
         unless ['string', 'symbol'].include?(type.downcase)
           if logger.nil? || logger.to_s.empty?
@@ -100,7 +134,7 @@ module NetHTTP
       end
 
       # Convert XML doc to a Ruby Hash.
-      def xml_2_hash(xml_doc, type = 'symbol', logger = nil)
+      def self.xml_2_hash(xml_doc, type = 'symbol', logger = nil)
         msg = "Invalid 'type' => #{type}.  Use either 'string' or 'symbol' (default)."
         unless ['string', 'symbol'].include?(type.downcase)
           if logger.nil? || logger.to_s.empty?
@@ -123,7 +157,7 @@ module NetHTTP
         end
       end
 
-      def format_xml_doc(xml_doc)
+      def self.format_xml_doc(xml_doc)
         case xml_doc
         when String
           formatted_xml_doc = Nokogiri::XML(xml_doc) { |c| c.options = Nokogiri::XML::ParseOptions::STRICT }
@@ -138,7 +172,7 @@ module NetHTTP
       end
 
       # Convert YAML doc to a Ruby Hash.
-      def yaml_2_hash(yaml_doc, type = 'symbol', logger = nil)
+      def self.yaml_2_hash(yaml_doc, type = 'symbol', logger = nil)
         msg = "Invalid 'type' => #{type}.  Use either 'string' or 'symbol' (default)."
         unless ['string', 'symbol'].include?(type.downcase)
           if logger.nil? || logger.to_s.empty?
@@ -167,7 +201,7 @@ module NetHTTP
         end
       end
 
-      def valid_json?(json_doc, logger = nil)
+      def self.valid_json?(json_doc, logger = nil)
         begin
           return false if json_doc.nil?
           return false if json_doc.empty?
@@ -187,7 +221,7 @@ module NetHTTP
         true
       end
 
-      def valid_xml?(xml_doc, logger = nil)
+      def self.valid_xml?(xml_doc, logger = nil)
         begin
           return false if xml_doc.nil?
           return false if xml_doc.empty?
@@ -210,7 +244,7 @@ module NetHTTP
         true
       end
 
-      def valid_html?(html_doc, logger = nil)
+      def self.valid_html?(html_doc, logger = nil)
         begin
           return false if html_doc.nil?
           return false if html_doc.empty?

data/lib/request/request.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative 'schema'
+require_relative '../core/core'
+
+module NetHTTP
+  class Client
+    def call_web_service(request_opts = {})
+      @response = case request_opts[:method].to_s.upcase
+                  when 'DELETE'
+                    delete(request_opts)
+                  when 'GET'
+                    get(request_opts)
+                  when 'POST'
+                    post(request_opts)
+                  when 'POST_FORM', 'POST_FORM_DATA'
+                    post_form(request_opts)
+                  when 'PUT'
+                    put(request_opts)
+                  else
+                    logger.debug("Request method => '#{request_opts[:method]}' not yet supported.")
+                    raise "Request method => '#{request_opts[:method]}' not yet supported."
+                  end
+
+      @response
+    end
+
+    def delete(opts = {})
+      raise 'Empty DELETE request options provided.' if opts.empty?
+
+      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 Port => ' + request_opts[:uri].port.to_s)
+      logger.debug('Request Path => ' + request_opts[:path])
+      Response.new(
+        response: client.delete(
+          request_opts[:path]
+        ),
+        logger: logger
+      )
+    end
+
+    def get(opts = {})
+      raise 'Empty GET request options provided.' if opts.empty?
+
+      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 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(
+        response: client.get(
+          request_opts[:path],
+          request_opts[:headers]
+        ),
+        logger: logger
+      )
+    end
+
+    def post(opts = {})
+      raise 'Empty POST request options provided.' if opts.empty?
+
+      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 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(
+        response: client.post(
+          request_opts[:path],
+          request_opts[:body],
+          request_opts[:headers]
+        ),
+        logger: logger
+      )
+    end
+
+    def post_form(opts = {})
+      raise 'Empty POST_FORM request options provided.' if opts.empty?
+
+      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 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(
+        response: client.post(
+          uri,
+          URI.encode_www_form(request_opts[:body]),
+          request_opts[:headers]
+        ),
+        logger: logger
+      )
+    end
+
+    alias post_form_data post_form
+
+    def put(opts = {})
+      raise 'Empty PUT request options provided.' if opts.empty?
+
+      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 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(
+        response: client.put(
+          request_opts[:path],
+          request_opts[:body],
+          request_opts[:headers]
+        ),
+        logger: logger
+      )
+    end
+
+    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
+    end
+  end
+end

data/lib/request/schema.rb

@@ -3,13 +3,10 @@
 require 'dry-validation'
 
 module NetHTTP
-  module Request
+  class Request
     Schema = Dry::Validation.Schema do
-      optional(:req_method).filled(type?: String)
-      optional(:method).filled(type?: String)
-      optional(:req_headers).maybe(type?: Hash)
+      required(:method).filled(type?: String)
       optional(:headers).maybe(type?: Hash)
-      optional(:req_body).maybe
       optional(:body).maybe
 
       rule(if_url_and_uri_are_nil_must_provide_path: [:uri, :url, :path]) do |uri, url, path|

data/lib/response/response.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'nokogiri'
+require 'ostruct'
+require_relative 'schema'
+require_relative '../core/core'
+require_relative '../core/utilities'
+
+module NetHTTP
+  class Response
+    attr_reader :logger,
+                :response
+
+    def initialize(opts = {})
+      send('logger=', opts[:logger])
+      puts opts[:response].class
+      Core.schema_validation(opts, NetHTTP::Response::Schema, logger) unless opts[:enforce_schema_validation] == false
+      @response = opts[:response]
+      log_response
+    end
+
+    alias resp response
+
+    def body
+      response.body
+    end
+
+    alias resp_body body
+    alias response_body body
+
+    def body_hash
+      begin
+        return NetHTTP::Core::Utilities.json_2_hash(body, 'symbol', logger) if valid_json?
+      rescue JSON::ParserError => err
+        logger.debug(err)
+      end
+      begin
+        return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_xml?
+      rescue Nokogiri::XML::SyntaxError => err
+        logger.debug(err)
+      end
+      begin
+        # TODO: revisit this if necessary
+        return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_html?
+      rescue Nokogiri::XML::SyntaxError => err
+        logger.debug(err)
+      end
+
+      {}
+    end
+
+    alias resp_body_hash body_hash
+    alias response_body_hash body_hash
+
+    def body_os
+      JSON.parse(body_hash.to_json, object_class: OpenStruct)
+    end
+
+    alias resp_body_os body_os
+    alias response_body_os body_os
+    alias body_open_struct body_os
+    alias resp_body_open_struct body_os
+    alias response_body_open_struct body_os
+
+    def code
+      response.code
+    end
+
+    alias resp_code code
+    alias response_code code
+
+    def headers
+      response_headers = {}
+      response.to_hash.each do |key, value|
+        response_headers[key] = value.flatten[0].to_s
+      end
+    end
+
+    alias resp_headers headers
+    alias response_headers headers
+
+    def headers_hash
+      NetHTTP::Core::Utilities.convert_hash_keys(
+        object: headers,
+        format: 'snake',
+        type: 'symbol'
+      )
+    end
+
+    alias resp_headers_hash headers_hash
+    alias response_headers_hash headers_hash
+
+    def headers_os
+      JSON.parse(headers_hash.to_json, object_class: OpenStruct)
+    end
+
+    alias resp_headers_os headers_os
+    alias response_headers_os headers_os
+    alias headers_open_struct headers_os
+    alias resp_headers_struct headers_os
+    alias response_headers_open_struct headers_os
+
+    def valid_json?
+      NetHTTP::Core::Utilities.valid_json?(body, logger)
+    end
+
+    def valid_xml?
+      NetHTTP::Core::Utilities.valid_xml?(body, logger)
+    end
+
+    def valid_html?
+      NetHTTP::Core::Utilities.valid_html?(body, logger)
+    end
+
+    private :logger,
+            :response
+
+    def logger=(logger = nil)
+      @logger = Core.get_logger(logger)
+    end
+
+    def log_response
+      logger.debug('Response Code => ' + code)
+      logger.debug('Response Headers => ')
+      logger.debug(headers)
+      logger.debug('Response Body => ')
+      logger.debug(body)
+    end
+  end
+end

data/lib/response/schema.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'dry-validation'
+
+module NetHTTP
+  class Response
+    Schema = Dry::Validation.Schema do
+      required(:response).filled(type?: Net::HTTPResponse)
+    end
+  end
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NetHTTP
-  VERSION = '0.0.4'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rb-net_http-client
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.1
 platform: ruby
 authors:
 - Ryan Bostian
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-22 00:00:00.000000000 Z
+date: 2019-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-validation
@@ -206,9 +206,10 @@ files:
 - lib/core/core.rb
 - lib/core/utilities.rb
 - lib/rb-net_http-client.rb
-- lib/request/ext.rb
+- lib/request/request.rb
 - lib/request/schema.rb
-- lib/response/ext.rb
+- lib/response/response.rb
+- lib/response/schema.rb
 - lib/version.rb
 - spec/integration/net_http/client/client_ext_spec.rb
 - spec/integration/net_http/client/client_spec.rb
@@ -244,8 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: A Simple Ruby HTTP Client

data/lib/request/ext.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../core/core'
-require_relative 'schema'
-
-module NetHTTP
-  module Request
-    module Ext
-      def call_web_service(opts = {})
-        logger = Core.assign_logger(self.logger ||= opts[:logger])
-
-        Core.schema_validation(opts, NetHTTP::Request::Schema, logger) unless opts[:enforce_schema_validation] == false
-
-        method = (opts[:method] ||= opts[:req_method] ||= opts[:request_method] ||= 'post').to_s.upcase
-        uri = Core.parse_uri(opts[:uri] ||= opts[:url] ||= self.uri)
-        path = opts[:path] ||= opts[:req_path] ||= opts[:request_path] ||= opts[:path] ||= uri.path ||= self.path
-        path = (path + '?' + uri.query) unless uri.query.nil? || path.include?('?')
-        headers = opts[:headers] ||= opts[:req_headers] ||= opts[:request_headers] ||= {}
-        body = opts[:body] ||= opts[:req_body] ||= opts[:request_body] ||= nil
-
-        resp = case method
-               when 'DELETE'
-                 logger.debug('Request Method => ' + method)
-                 logger.debug('Request Host => ' + uri.host.to_s)
-                 logger.debug('Request Path => ' + path)
-                 delete(path)
-               when 'GET'
-                 logger.debug('Request Method => ' + method)
-                 logger.debug('Request Host => ' + uri.host.to_s)
-                 logger.debug('Request Path => ' + path)
-                 logger.debug('Request Headers =>')
-                 logger.debug(headers)
-                 get(path, headers)
-               when 'POST'
-                 logger.debug('Request Method => ' + method)
-                 logger.debug('Request Host => ' + uri.host.to_s)
-                 logger.debug('Request Path => ' + path)
-                 logger.debug('Request Headers =>')
-                 logger.debug(headers)
-                 logger.debug('Request Body =>')
-                 logger.debug(body)
-                 post(path, body, headers)
-               when 'POST_FORM', 'POST_FORM_DATA'
-                 logger.debug('Request Method => ' + method)
-                 logger.debug('Request Host => ' + uri.host.to_s)
-                 logger.debug('Request Path => ' + path)
-                 logger.debug('Request Headers =>')
-                 logger.debug(headers)
-                 logger.debug('Request Body =>')
-                 logger.debug(URI.encode_www_form(body))
-                 post(uri, URI.encode_www_form(body), headers)
-               when 'PUT'
-                 logger.debug('Request Method => ' + method)
-                 logger.debug('Request Host => ' + uri.host.to_s)
-                 logger.debug('Request Path => ' + path)
-                 logger.debug('Request Headers =>')
-                 logger.debug(headers)
-                 logger.debug('Request Body =>')
-                 logger.debug(body)
-                 put(path, body, headers)
-               else
-                 logger.debug("Request method => '#{method}' not yet supported.")
-                 raise "Request method => '#{method}' not yet supported."
-               end
-        logger.debug('Response Code => ' + resp.code)
-        logger.debug('Response Headers => ')
-        logger.debug(resp.headers)
-        logger.debug('Response Body => ')
-        logger.debug(resp.body)
-        resp
-      end
-
-      alias call_api call_web_service
-      alias call_service call_web_service
-      alias execute_request call_web_service
-      alias send_request call_web_service
-      alias submit_request call_web_service
-    end
-  end
-end
-
-module Net
-  class HTTP
-    include NetHTTP::Core
-    include NetHTTP::Request::Ext
-  end
-end

data/lib/response/ext.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'nokogiri'
-require 'ostruct'
-require_relative '../core/core'
-require_relative '../core/utilities'
-
-module NetHTTP
-  module Response
-    module Ext
-      def resp_code
-        code
-      end
-
-      alias response_code resp_code
-
-      def headers
-        resp_headers = {}
-        headers = to_hash
-        headers.each do |key, value|
-          resp_headers[key] = value.flatten[0].to_s
-        end
-      end
-
-      alias resp_headers headers
-      alias response_headers headers
-
-      def headers_hash
-        NetHTTP::Core::Utilities.convert_hash_keys(
-          object: headers,
-          format: 'snake',
-          type: 'symbol'
-        )
-      end
-
-      alias resp_headers_hash headers_hash
-      alias response_headers_hash headers_hash
-
-      def headers_os
-        JSON.parse(headers_hash.to_json, object_class: OpenStruct)
-      end
-
-      alias resp_headers_os headers_os
-      alias response_headers_os headers_os
-      alias headers_open_struct headers_os
-      alias resp_headers_struct headers_os
-      alias response_headers_open_struct headers_os
-
-      def resp_body
-        body
-      end
-
-      alias response_body resp_body
-
-      def body_hash
-        begin
-          return NetHTTP::Core::Utilities.json_2_hash(body, 'symbol', logger) if valid_json?
-        rescue JSON::ParserError => err
-          logger.debug(err)
-        end
-        begin
-          return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_xml?
-        rescue Nokogiri::XML::SyntaxError => err
-          logger.debug(err)
-        end
-        begin
-          # TODO: update this to work if necessary
-          # probably makes more sense to parse HTML using nokogiri
-          return NetHTTP::Core::Utilities.xml_2_hash(body, 'symbol', logger) if valid_html?
-        rescue Nokogiri::XML::SyntaxError => err
-          logger.debug(err)
-        end
-
-        {}
-      end
-
-      alias resp_body_hash body_hash
-      alias response_body_hash body_hash
-
-      def body_os
-        JSON.parse(body_hash.to_json, object_class: OpenStruct)
-      end
-
-      alias resp_body_os body_os
-      alias response_body_os body_os
-      alias body_open_struct body_os
-      alias resp_body_open_struct body_os
-      alias response_body_open_struct body_os
-
-      def valid_json?
-        NetHTTP::Core::Utilities.valid_json?(body, logger)
-      end
-
-      def valid_xml?
-        NetHTTP::Core::Utilities.valid_xml?(body, logger)
-      end
-
-      def valid_html?
-        NetHTTP::Core::Utilities.valid_html?(body, logger)
-      end
-    end
-  end
-end
-
-module Net
-  class HTTPResponse
-    include NetHTTP::Core
-    include NetHTTP::Response::Ext
-  end
-end