rb-net_http-client 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43106fa08999d370c0d5d28bdf9dc5ce1fecd7ecb32b72ee96d7b12ed63a7259
+  data.tar.gz: 773fba38a078d87ab259dfa8c7a575d68e4cf2307dfed0d7affbacbb09dd2040
+SHA512:
+  metadata.gz: e7867815e0b13eefc9b15d35ab29af789879849f8d2d3eca4853cd273e5196764b2cd849a8ec0ff32ddb29b6b33712d76d1a5c80ee9db93ddb413e7ce3c58f22
+  data.tar.gz: d278c746b537012f7767f429a1554059db30771ee9348dd7acbabd1620ff6a5c8f074a3771e1bd6ead4cd3e24583ce499334f52cda924e28603f8cd024f911f8

data/lib/client/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'net/https'
+require_relative 'ext'
+require_relative 'schema'
+require_relative '../core/core'
+require_relative '../request/ext'
+require_relative '../response/ext'
+
+module NetHTTP
+  module_function
+
+  def client(opts)
+    logger = Core.assign_logger(opts[:logger])
+
+    Core.schema_validation(opts, NetHTTP::Client::Schema, logger) unless opts[:enforce_schema_validation] == false
+
+    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]))
+    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])
+    end
+
+    client
+  end
+end

data/lib/client/ext.rb

@@ -0,0 +1,120 @@
+# 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
+
+      Core.parse_uri(proxy_uri ||= ENV['http_proxy'] ||= ENV['HTTP_PROXY'] ||= ENV['https_proxy'] ||= ENV['HTTPS_PROXY'])
+    end
+
+    def use_proxy(use_proxy)
+      return false if use_proxy == false
+
+      true
+    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'
+      end
+      return false if use_ssl == false
+
+      true
+    end
+
+    def open_timeout(open_timeout)
+      (open_timeout ||= 60).to_s.to_i
+    end
+
+    def read_timeout(read_timeout)
+      (read_timeout ||= 60).to_s.to_i
+    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)
+    end
+
+    def cert(pkcs12)
+      return nil if pkcs12.nil?
+      return nil if pkcs12.to_s.empty?
+
+      OpenSSL::X509::Certificate.new(pkcs12.certificate)
+    end
+
+    def key(pkcs12)
+      return nil if pkcs12.nil?
+      return nil if pkcs12.to_s.empty?
+
+      OpenSSL::PKey::RSA.new(pkcs12.key)
+    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?
+
+      File.binread(ssl_path + '/' + ca_file)
+    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?
+
+      verify_mode
+    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
+
+      attr_writer :host,
+                  :port,
+                  :path,
+                  :logger,
+                  :uri,
+                  :url,
+                  :use_proxy,
+                  :use_ssl
+
+      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
+        end
+      end
+    end
+  end
+end
+
+module Net
+  class HTTP
+    include NetHTTP::Core
+    include NetHTTP::Client::Ext
+  end
+end

data/lib/client/schema.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'dry-validation'
+
+module NetHTTP
+  module Client
+    Schema = Dry::Validation.Schema do
+      configure do
+        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(:host).maybe(type?: String)
+      optional(:port).maybe(type?: Integer)
+      optional(:path).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(:read_timeout).filled(type?: Integer)
+
+      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?))
+      end
+
+      rule(if_url_and_uri_are_nil_must_provide_scheme_or_port: [:uri, :url, :scheme, :port]) do |uri, url, scheme, port|
+        uri.empty?.then(url.empty?.then(scheme.empty?.then(port.filled?)))
+        uri.empty?.then(url.empty?.then(port.empty?.then(scheme.filled?)))
+      end
+    end
+  end
+end

data/lib/core/core.rb

@@ -0,0 +1,75 @@
+# 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)
+      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
+    end
+
+    def schema_validation(opts, schema, logger = nil)
+      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.'
+    end
+  end
+end

data/lib/core/utilities.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'nokogiri'
+require 'yaml'
+
+module NetHTTP
+  module Core
+    module Utilities
+      module_function
+
+      # CamelCase to snake_case
+      def camel_2_snake(key, type = nil)
+        new_key = key.to_s
+                     .tr('::', '/')
+                     .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                     .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                     .tr('-', '_')
+                     .downcase
+
+        case type.downcase
+        when 'string'
+          return new_key.to_s
+        when 'symbol'
+          return new_key.to_sym
+        end
+
+        new_key
+      end
+
+      # snake_case to CamelCase
+      def 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('')
+
+        case type.downcase
+        when 'string'
+          return new_key.to_s
+        when 'symbol'
+          return new_key.to_sym
+        end
+
+        new_key
+      end
+
+      # 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?
+
+        case request[:object]
+        when Hash
+          new_hash = {}
+          request[:object].each do |key, value|
+            value = convert_hash_keys(
+              object: value,
+              format: request[:format],
+              type: request[:type]
+            )
+            case request[:format].downcase
+            when 'snake'
+              new_key = camel_2_snake(key, request[:type])
+            when 'camel'
+              new_key = snake_2_camel(key, request[: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]) }
+        end
+
+        request[:object]
+      end
+
+      # Convert JSON doc to a Ruby Hash.
+      def 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?
+            puts msg
+          else
+            logger.debug(msg)
+          end
+          raise msg
+        end
+
+        json_doc = JSON.parse(json_doc) if json_doc.class == String
+
+        begin
+          convert_hash_keys(
+            object: json_doc,
+            format: 'snake',
+            type: type.downcase
+          )
+        rescue RuntimeError => err
+          raise err
+        end
+      end
+
+      # Convert XML doc to a Ruby Hash.
+      def 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?
+            puts msg
+          else
+            logger.debug(msg)
+          end
+          raise msg
+        end
+
+        xml_doc = Hash.from_xml(format_xml_doc(xml_doc))
+        begin
+          convert_hash_keys(
+            object: xml_doc,
+            format: 'snake',
+            type: type.downcase
+          )
+        rescue RuntimeError => err
+          raise err
+        end
+      end
+
+      def format_xml_doc(xml_doc)
+        case xml_doc
+        when String
+          formatted_xml_doc = Nokogiri::XML(xml_doc) { |c| c.options = Nokogiri::XML::ParseOptions::STRICT }
+          formatted_xml_doc = formatted_xml_doc.remove_namespaces!.to_s
+        when Nokogiri::XML::Document
+          formatted_xml_doc = xml_doc.remove_namespaces!.to_s
+        else
+          raise "Unrecognized 'xml_doc' class => '#{xml_doc.class}'"
+        end
+
+        formatted_xml_doc
+      end
+
+      # Convert YAML doc to a Ruby Hash.
+      def 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?
+            puts msg
+          else
+            logger.debug(msg)
+          end
+          raise msg
+        end
+
+        case yaml
+        when Hash
+          yaml_doc = yaml_doc.to_hash
+        when String
+          yaml_doc = YAML.safe_load(yaml_doc).to_hash
+        end
+
+        begin
+          convert_hash_keys(
+            object: yaml_doc,
+            format: 'snake',
+            type: type.downcase
+          )
+        rescue RuntimeError => err
+          raise err
+        end
+      end
+
+      def valid_json?(json_doc, logger = nil)
+        begin
+          return false if json_doc.nil?
+          return false if json_doc.empty?
+
+          JSON.parse(json_doc)
+        rescue JSON::ParserError => err
+          if logger.nil? || logger.to_s.empty?
+            puts 'WARNING - JSON syntax / parsing errors detected:'
+            puts err
+          else
+            logger.debug('WARNING - JSON syntax / parsing errors detected:')
+            logger.debug(err)
+          end
+          return false
+        end
+
+        true
+      end
+
+      def valid_xml?(xml_doc, logger = nil)
+        begin
+          return false if xml_doc.nil?
+          return false if xml_doc.empty?
+
+          begin
+            parse_errors = Nokogiri::XML(xml_doc).errors { |c| c.options = Nokogiri::XML::ParseOptions::STRICT }
+            Nokogiri::XML(xml_doc) { |c| c.options = Nokogiri::XML::ParseOptions::STRICT }
+          rescue Nokogiri::XML::SyntaxError
+            if logger.nil? || logger.to_s.empty?
+              puts 'WARNING - XML syntax / parsing errors detected:'
+              puts parse_errors
+            else
+              logger.debug('WARNING - XML parsing / syntax errors detected:')
+              logger.debug(parse_errors)
+            end
+            return false
+          end
+        end
+
+        true
+      end
+
+      def valid_html?(html_doc, logger = nil)
+        begin
+          return false if html_doc.nil?
+          return false if html_doc.empty?
+          return false unless html_doc.include?('<html>')
+          return false unless html_doc.include?('</html>')
+          return false unless html_doc.include?('<body>')
+          return false unless html_doc.include?('</body>')
+          return false unless Nokogiri::HTML(html_doc).errors.empty?
+
+          begin
+            parse_errors = Nokogiri::HTML.parse(html_doc).validate
+          rescue Nokogiri::XML::SyntaxError
+            if logger.nil? || logger.to_s.empty?
+              puts 'WARNING - HTML syntax / parsing errors detected:'
+              puts parse_errors
+            else
+              logger.debug('WARNING - HTML syntax / parsing errors detected:')
+              logger.debug(parse_errors)
+            end
+            return true
+          end
+        rescue RuntimeError => err
+          raise err
+        end
+
+        true
+      end
+    end
+  end
+end