kis_http 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 90cf8804c9b8fab2d42e58567bc05f304344fac286b6874240a20e3e832b8852
+  data.tar.gz: a0eb1a0095d20ba88ffbffc95accc6a08e95e6081811dccb87002b8ae1cb1f80
+SHA512:
+  metadata.gz: 9f72fcfc774f7167b69d1affa960f9cee2bfa75f63efe2e6da743f92348f6a96b8474f9f05b537e7107f924bd95328468c9fe26c4f7b37d1e543a0e287bdc10c
+  data.tar.gz: 29f28c1523dc105a1360dd80daee941f61fd9de9b9fb890460c488b22b2a188e31a680a76b57e55c02b33137718f5e9742942db5c20eab00edcdf50ac3b54f05

data/lib/kis_http.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'kis_http/version'
+require 'net/http'
+
+# All the HTTP things
+module KisHttp
+  class Error < StandardError; end
+
+  class << self
+    def get(url, **kwargs)
+      request(url, **kwargs) do |uri|
+        Net::HTTP::Get.new(uri)
+      end
+    end
+
+    def post(url, **kwargs)
+      request(url, **kwargs) do |uri|
+        Net::HTTP::Post.new(uri)
+      end
+    end
+
+    def put(url, **kwargs)
+      request(url, **kwargs) do |uri|
+        Net::HTTP::Put.new(uri)
+      end
+    end
+
+    private
+
+    def request(url, body: nil, headers: nil, options: nil)
+      options = Rest.Options(options) if options
+
+      uri = URI("#{url}#{options}")
+
+      request = yield uri.request_uri
+
+      Rest.Headers(headers).assign_each_to(request) if headers
+
+      request.body = body ? JSON.generate(body) : ''
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+
+      http.request(request)
+    end
+  end
+end

data/lib/kis_http/headers.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+# TLD
+module KisHttp
+  # A header builder class for outgoing requests
+  class Headers
+    extend Forwardable
+    # @!macro [attach] def_delegators
+    #   @!method each_pair
+    #     Forwards to $1.
+    #     @see Hash#each_pair
+    #   @!method fetch
+    #     Forwards to $1.
+    #     @see Hash#fetch
+    def_delegators :@heads, :each_pair, :fetch
+
+    def initialize(args = {})
+      build(args)
+    end
+
+    # Add or update the request headers
+    #
+    # @return [Headers] self
+    def build(args = {})
+      @heads ||= {}
+
+      args.to_h.each do |(key, value)|
+        @heads[key] = value
+      end
+
+      self
+    end
+
+    # Assign each header to object via :[]
+    def assign_each_to(obj)
+      each_pair do |header, value|
+        obj[header] = value
+      end
+
+      obj
+    end
+
+    # Remove key/value from headers via key
+    #
+    # @param key [Symbol, String] key to look up
+    # @return [String, Symbol, nil] returns value if key found, `nil` otherwise.
+    def remove(key)
+      @heads.delete(key)
+    end
+
+    # Add the values of one `Headers` into another
+    #
+    # @param other [Headers] instance of `Headers`
+    # @return [Headers]
+    def +(other)
+      raise TypeError, "Headers type expected, #{other.class} given" \
+        unless other.is_a? Headers
+
+      @heads.merge(other.instance_variable_get(:@heads))
+
+      self
+    end
+
+    # @return [Hash] hash of the `Headers`
+    def to_h
+      @heads
+    end
+  end
+
+  def self.Headers(obj)
+    if obj.is_a? Rest::Headers
+      obj
+    elsif obj.is_a? Hash
+      Rest::Headers.new(**obj)
+    elsif obj.is_a? Array
+      Rest::Headers.new(**obj.to_h)
+    else
+      raise 'Invalid object type for Headers!'
+    end
+  end
+end

data/lib/kis_http/options.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# TLD
+module KisHttp
+  # A url options builder class for outgoing requests.
+  class Options
+    def initialize(args = {})
+      build(args)
+    end
+
+    # url safe rendering of options for the url
+    #
+    # @return [String] url options
+    def opts
+      if @opts.empty?
+        ''
+      else
+        "?#{@opts.join('&')}"
+      end
+    end
+
+    # Add or update url options
+    #
+    # @return [Options] self
+    def build(args = {})
+      @opts ||= []
+
+      args.to_h.each do |(key, value)|
+        remove(key)
+        @opts.push("#{key}=#{value}")
+      end
+
+      self
+    end
+
+    # Fetch the `key=value`
+    #
+    # @param [Symbol, String] key of the key/value pair to fetch
+    # @return [String]
+    def fetch(key)
+      @opts.each do |item|
+        return item if key.to_s == split.call(item).first
+      end
+
+      raise KeyError, "key not found #{key}" unless block_given?
+
+      yield
+    end
+
+    # Fetch and remove `key=value`.  Modifies `Options`.
+    #
+    # @param [Symbol, String] key of the key/value pair to fetch
+    # @return [String]
+    def fetch!(key, &block)
+      result = fetch(key, &block)
+      remove(key)
+      result
+    end
+
+    # Execute a block of code and restore original `Options` state afterwards
+    # @yield [Options]
+    def immutable
+      old = @opts
+      result = yield self
+      @opts = old
+      result
+    end
+
+    # Remove key/value from options via key
+    #
+    # @param key [Symbol, String] key to look up
+    # @return [String, nil] returns a `String` if key found, `nil` otherwise.
+    def remove(key)
+      return_value = nil
+
+      @opts = @opts.delete_if do |item|
+        head, tail = split.call item
+
+        return_value = tail if head == key.to_s
+      end
+
+      return_value
+    end
+
+    # this purges all options
+    #
+    # @return [Options] self
+    def reset!
+      @opts = []
+
+      self
+    end
+
+    # Add the values of one `Options` into another
+    #
+    # @param other [Options] instance of `Options`
+    # @return [Options]
+    def +(other)
+      unless other.is_a? Options
+        raise TypeError, "Options type expected, #{other.class} given"
+      end
+
+      update other.instance_variable_get(:@opts)
+
+      self
+    end
+
+    # (see #opts)
+    def to_s
+      opts
+    end
+
+    # @return [Hash] hash of the `Options`
+    def to_h
+      @opts.map(&split).to_h
+    end
+
+    private # @private
+
+    def split
+      ->(entry) { entry.split('=') }
+    end
+
+    def parse(other)
+      return other.split('&').map(&split).to_h if other.is_a? String
+
+      other.map(&split).to_h
+    end
+
+    def update(other)
+      return self unless other
+
+      build(parse(other))
+    end
+  end
+
+  def self.Options(obj)
+    if obj.is_a? Rest::Options
+      obj
+    elsif obj.is_a? Hash
+      Rest::Options.new(**obj)
+    elsif obj.is_a? Array
+      Rest::Options.new(**obj.to_h)
+    else
+      raise 'Invalid object type for Options!'
+    end
+  end
+end

data/lib/kis_http/version.rb

@@ -0,0 +1,3 @@
+module KisHttp
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: kis_http
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel P. Clark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-15 00:00:00.000000000 Z
+dependencies: []
+description: DRY for Net::HTTP
+email:
+- 6ftdan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kis_http.rb
+- lib/kis_http/headers.rb
+- lib/kis_http/options.rb
+- lib/kis_http/version.rb
+homepage: https://github.com/danielpclark/kist_http
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Keep it Simple for Net::HTTP
+test_files: []