httpsensible 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32e2632ab04452677c5315bc439fdbf9c053005dda83623439e1cc9a90e638d2
+  data.tar.gz: 39e24e3cfe6c07dc361d07697b00610dfa67ab2bb6b0f117fc50a243375cc4ca
+SHA512:
+  metadata.gz: 2bdf63c8455e72ab83fe6ddc81e4d9a4fb12e9809a9e6c21341ad545cbdc81e44ff35be445115ca8b6aefa580dac6e09a39bef2dad7fcf6cfe62afc5e2d779ed
+  data.tar.gz: dd2089be9ba6e7db3ad1c564dd0cd9251275354aac38b9f541eaf81bc9fc51761ef33b19b2851b83accb44881822a2430df3f8df150a6a04ecefba7c27e0f428

data/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_gem:
+  rubocop-standard:
+    - config/default.yml
+    - config/minitest.yml

data/.ruby-version

@@ -0,0 +1 @@
+3.2.1

data/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "[markdown]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[ruby]": {
+        "editor.defaultFormatter": "Shopify.ruby-lsp"
+    }
+}

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-07-10
+
+- Initial release

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in httpsensible.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rubocop", "~> 1.21"
+gem "rubocop-standard"
+
+gem "amazing_print", require: false
+gem "debug", require: false
+
+gem "sorbet", group: :development
+gem "sorbet-runtime"
+gem "tapioca", require: false, group: :development

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Garen J. Torikian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# Httpsensible
+
+An HTTP client with sensible defaults.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add httpsensible
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install httpsensible
+
+## Usage
+
+```ruby
+client =  Httpsensible::Client.new
+client.get("https://yetto.app")
+
+# `last_response` is always set after each call
+unless client.last_response.unavailable? # false
+  puts last_response.parsed_json_body
+end
+
+# make a JWT; `iat` and `exp` are optional
+encoded_jwt = Httpsensible::JWT.encode_jwt(pem, iss)
+
+# you can also provide headers
+response = client.with_headers({ "Authorization" => "Bearer #{encoded_jwt}" }).post("https://api.yetto.app")
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yettoapp/httpsensible.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubygems/package_task"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+GEMSPEC = Bundler.load_gemspec("httpsensible.gemspec")
+gem_path = Gem::PackageTask.new(GEMSPEC).define
+desc "Package the ruby gem"
+task "package" => [gem_path]

data/lib/httpsensible/client/response.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Httpsensible
+  class Client
+    class Response
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      # sig { params(response: T.any(HTTPX::Response, HTTPX::ErrorResponse)).returns(String) }
+      def to_s
+        case @response
+        when HTTPX::Response
+          "#{@response.status}, #{@response.headers}, #{@response.body}"
+        when HTTPX::ErrorResponse
+          @response.error.message
+        else
+          ""
+        end
+      end
+
+      # sig { params(response: T.any(HTTPX::Response, HTTPX::ErrorResponse)).returns(T::Boolean) }
+      def parsed_json_body
+        JSON.parse(raw_body)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def raw_body
+        @raw_body ||= @response.body.read
+      end
+
+      # sig { params(response: T.any(HTTPX::Response, HTTPX::ErrorResponse)).returns(T::Boolean) }
+      def unavailable?
+        return true if @response.nil?
+        return false if (200..299).cover?(@response.status)
+
+        case @response
+        when HTTPX::Response
+          raw_body.nil? || raw_body.empty? || raw_body == "{}"
+        when HTTPX::ErrorResponse
+          true
+        end
+      end
+
+      def available?
+        !unavailable?
+      end
+    end
+  end
+end

data/lib/httpsensible/client.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "client/response"
+
+require "httpx"
+
+module Httpsensible
+  class Client
+    attr_reader :client
+
+    def initialize(user_agent: nil)
+      headers = {
+        "content-type" => "application/json",
+        "accept" => "application/json",
+      }
+      if !user_agent.nil? && !user_agent.empty?
+        headers["user-agent"] = user_agent
+      end
+
+      @client = HTTPX.plugin(:persistent)
+        .plugin(:retries, max_retries: 3)
+        .with_headers(headers)
+    end
+
+    def with_headers(headers)
+      @client = @client.with(headers: headers)
+      self
+    end
+
+    ["head", "get", "post", "put", "delete", "trace", "options", "connect", "patch"].each do |meth|
+      class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        def #{meth}(*uri, **options)
+          @last_response = Httpsensible::Client::Response.new(@client.#{meth}(*uri, **options))   #   @last_response = @client.get(*uri, **options)
+        end
+      MOD
+    end
+  end
+end

data/lib/httpsensible/jwt.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "jwt"
+
+module Httpsensible
+  module JWT
+    JWT_ALGORITHM = "RS256"
+
+    class << self
+      def encode_jwt(pem, iss, iat: Time.now.to_i - 60, exp: Time.now.to_i + (10 * 60))
+        private_key = OpenSSL::PKey::RSA.new(pem)
+        payload = {
+          # issued at time, 60 seconds in the past to allow for clock drift
+          iat: iat,
+          # JWT expiration time
+          exp: exp,
+          # Identifier
+          iss: iss,
+        }
+
+        ::JWT.encode(payload, private_key, JWT_ALGORITHM)
+      end
+    end
+  end
+end

data/lib/httpsensible/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Httpsensible
+  VERSION = "0.1.1"
+end

data/lib/httpsensible.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "httpsensible/version"
+require_relative "httpsensible/client"
+require_relative "httpsensible/jwt"
+
+module Httpsensible
+  class Error < StandardError; end
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/dsl/active_support/callbacks.rbi

@@ -0,0 +1,22 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ActiveSupport::Callbacks`.
+# Please instead update this file by running `bin/tapioca dsl ActiveSupport::Callbacks`.
+
+module ActiveSupport::Callbacks
+  include GeneratedInstanceMethods
+
+  mixes_in_class_methods GeneratedClassMethods
+
+  module GeneratedClassMethods
+    def __callbacks; end
+    def __callbacks=(value); end
+    def __callbacks?; end
+  end
+
+  module GeneratedInstanceMethods
+    def __callbacks; end
+    def __callbacks?; end
+  end
+end

data/sorbet/rbi/gems/activesupport@7.0.6.rbi

@@ -0,0 +1,14 @@
+# typed: false
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `activesupport` gem.
+# Please instead update this file by running `bin/tapioca gem activesupport`.
+
+class LoadError < ::ScriptError
+  include ::DidYouMean::Correctable
+end
+
+class NameError < ::StandardError
+  include ::ErrorHighlight::CoreExt
+  include ::DidYouMean::Correctable
+end