api-generator 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a140a5dadd45d555260b30f52d6d837c9b15533fb53d4470295ee2660568c704
+  data.tar.gz: 5f33f87739b38ef57fd49528fd77bd28dd3416cf7a637055c734954069a209b2
+SHA512:
+  metadata.gz: 54758dffffe9e86aac09cda047b6bef2b4e337e9e63d5cb4ef1e9019116153f5f6805075b4fff2daafc6f6a6d93a300fe01e9acea8d59389e0820279410530d2
+  data.tar.gz: 39f53e64a8a96bdd46d45181c083f7c43fbee01b1c8af524288733fe5c41fa6b20f1b09082e874859aa685d9eecd8e7c7cff387261324d81b5fbb4e0bbab79c8

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'faraday'
+
+gem 'sorbet', group: :development
+gem 'sorbet-runtime'

data/Gemfile.lock

@@ -0,0 +1,21 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    faraday (0.17.0)
+      multipart-post (>= 1.2, < 3)
+    multipart-post (2.1.1)
+    sorbet (0.4.5049)
+      sorbet-static (= 0.4.5049)
+    sorbet-runtime (0.4.5049)
+    sorbet-static (0.4.5049-universal-darwin-14)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  faraday
+  sorbet
+  sorbet-runtime
+
+BUNDLED WITH
+   1.17.3

data/api-generator.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'api_generator/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'api-generator'
+  spec.version = ApiGenerator::VERSION
+  spec.authors = ['Kyle Hiller']
+  spec.email = ['kyle.r.hiller@gmail.com']
+  spec.summary = 'Generates API calls to Faraday using metaprogramming'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|rbi)/})
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday'
+  spec.add_dependency 'sorbet-runtime'
+
+  spec.add_development_dependency 'sorbet'
+end

data/lib/api_generator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# typed: true
+
+require 'api_generator/client'
+require 'api_generator/url'
+require 'api_generator/version'
+
+module ApiGenerator
+end

data/lib/api_generator/client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# typed: true
+
+module ApiGenerator
+  class Client
+    extend T::Sig
+
+    attr_reader :url
+    attr_accessor :rest_method
+
+    REST_METHODS = %i[
+      put
+      get
+      patch
+      delete
+      post
+    ]
+
+    sig { params(url: ApiGenerator::Url, rest_method: Symbol).void }
+    def initialize(url: ApiGenerator::Url.new(""), rest_method: :get)
+      @url = T.let(url, ApiGenerator::Url)
+      @rest_method = T.let(rest_method, Symbol)
+    end
+
+
+    sig { params(options: T::Hash[Symbol, T.any(String, Symbol, Integer, Date, OpenSSL::ASN1::Boolean)]).returns(Faraday::Response) }
+    def execute(options)
+      Faraday.send(rest_method) do |req|
+        req.params = options
+        req.url = url.url
+      end
+    end
+
+    sig { params(method: Symbol, args: T.untyped, block: T.nilable(T.proc.void)).returns(T.self_type) }
+    def method_missing(method, *args, &block)
+      if REST_METHODS.any?(method)
+        return ApiGenerator::Client.new(url: url, rest_method: method)
+      end
+
+      ApiGenerator::Client.new(url: ApiGenerator::Url.send(url), rest_method: rest_method)
+    end
+  end
+end

data/lib/api_generator/url.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# typed: true
+
+module ApiGenerator
+  class Url
+    extend T::Sig
+
+    attr_reader :url
+
+    sig { params(url: String).void }
+
+    def initialize(url)
+      @url = url
+    end
+
+    sig { params(method: Symbol, args: T.untyped, block: T.nilable(T.proc.void)).returns(T.self_type) }
+    def method_missing(method, *args, &block)
+     ApiGenerator::Url.new(File.join(url, method))
+    end
+  end
+end

data/lib/api_generator/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# typed: true
+
+module ApiGenerator
+  VERSION = '0.0.2'
+end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/faraday.rbi

@@ -0,0 +1,531 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/faraday/all/faraday.rbi
+#
+# faraday-0.17.0
+module Faraday
+  def self.const_missing(name); end
+  def self.default_adapter; end
+  def self.default_adapter=(adapter); end
+  def self.default_connection; end
+  def self.default_connection=(arg0); end
+  def self.default_connection_options; end
+  def self.default_connection_options=(options); end
+  def self.ignore_env_proxy; end
+  def self.ignore_env_proxy=(arg0); end
+  def self.lib_path; end
+  def self.lib_path=(arg0); end
+  def self.method_missing(name, *args, &block); end
+  def self.new(url = nil, options = nil); end
+  def self.require_lib(*libs); end
+  def self.require_libs(*libs); end
+  def self.respond_to?(symbol, include_private = nil); end
+  def self.root_path; end
+  def self.root_path=(arg0); end
+end
+module Faraday::Utils
+  def URI(url); end
+  def build_nested_query(params); end
+  def build_query(params); end
+  def deep_merge!(target, hash); end
+  def deep_merge(source, hash); end
+  def default_params_encoder; end
+  def default_uri_parser; end
+  def default_uri_parser=(parser); end
+  def escape(s); end
+  def normalize_params(params, name, v = nil); end
+  def normalize_path(url); end
+  def parse_nested_query(query); end
+  def parse_query(query); end
+  def self.default_params_encoder=(arg0); end
+  def sort_query_params(query); end
+  def unescape(s); end
+  extend Faraday::Utils
+end
+class Faraday::Utils::Headers < Hash
+  def [](k); end
+  def []=(k, v); end
+  def delete(k); end
+  def fetch(k, *args, &block); end
+  def has_key?(k); end
+  def include?(k); end
+  def initialize(hash = nil); end
+  def initialize_copy(other); end
+  def initialize_names; end
+  def key?(k); end
+  def member?(k); end
+  def merge!(other); end
+  def merge(other); end
+  def names; end
+  def parse(header_string); end
+  def replace(other); end
+  def self.allocate; end
+  def self.from(value); end
+  def to_hash; end
+  def update(other); end
+end
+class Faraday::Utils::ParamsHash < Hash
+  def [](key); end
+  def []=(key, value); end
+  def convert_key(key); end
+  def delete(key); end
+  def has_key?(key); end
+  def include?(key); end
+  def key?(key); end
+  def member?(key); end
+  def merge!(params); end
+  def merge(params); end
+  def merge_query(query, encoder = nil); end
+  def replace(other); end
+  def to_query(encoder = nil); end
+  def update(params); end
+end
+class Faraday::Options < Struct
+  def [](key); end
+  def clear; end
+  def deep_dup; end
+  def delete(key); end
+  def each; end
+  def each_key; end
+  def each_value; end
+  def empty?; end
+  def fetch(key, *args); end
+  def has_key?(key); end
+  def has_value?(value); end
+  def inspect; end
+  def key?(key); end
+  def keys; end
+  def merge!(other); end
+  def merge(other); end
+  def self.attribute_options; end
+  def self.fetch_error_class; end
+  def self.from(value); end
+  def self.inherited(subclass); end
+  def self.memoized(key); end
+  def self.memoized_attributes; end
+  def self.options(mapping); end
+  def self.options_for(key); end
+  def symbolized_key_set; end
+  def to_hash; end
+  def update(obj); end
+  def value?(value); end
+  def values_at(*keys); end
+end
+class Anonymous_Faraday_Options_1 < Faraday::Options
+  def bind; end
+  def bind=(_); end
+  def boundary; end
+  def boundary=(_); end
+  def context; end
+  def context=(_); end
+  def oauth; end
+  def oauth=(_); end
+  def open_timeout; end
+  def open_timeout=(_); end
+  def params_encoder; end
+  def params_encoder=(_); end
+  def proxy; end
+  def proxy=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def timeout; end
+  def timeout=(_); end
+  def write_timeout; end
+  def write_timeout=(_); end
+end
+class Faraday::RequestOptions < Anonymous_Faraday_Options_1
+  def []=(key, value); end
+end
+class Anonymous_Faraday_Options_2 < Faraday::Options
+  def ca_file; end
+  def ca_file=(_); end
+  def ca_path; end
+  def ca_path=(_); end
+  def cert_store; end
+  def cert_store=(_); end
+  def certificate; end
+  def certificate=(_); end
+  def client_cert; end
+  def client_cert=(_); end
+  def client_key; end
+  def client_key=(_); end
+  def max_version; end
+  def max_version=(_); end
+  def min_version; end
+  def min_version=(_); end
+  def private_key; end
+  def private_key=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def verify; end
+  def verify=(_); end
+  def verify_depth; end
+  def verify_depth=(_); end
+  def verify_mode; end
+  def verify_mode=(_); end
+  def version; end
+  def version=(_); end
+end
+class Faraday::SSLOptions < Anonymous_Faraday_Options_2
+  def disable?; end
+  def verify?; end
+end
+class Anonymous_Faraday_Options_3 < Faraday::Options
+  def password; end
+  def password=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def uri; end
+  def uri=(_); end
+  def user; end
+  def user=(_); end
+end
+class Faraday::ProxyOptions < Anonymous_Faraday_Options_3
+  def host(*args, &block); end
+  def host=(*args, &block); end
+  def password; end
+  def path(*args, &block); end
+  def path=(*args, &block); end
+  def port(*args, &block); end
+  def port=(*args, &block); end
+  def scheme(*args, &block); end
+  def scheme=(*args, &block); end
+  def self.from(value); end
+  def user; end
+  extend Forwardable
+end
+class Anonymous_Faraday_Options_4 < Faraday::Options
+  def builder; end
+  def builder=(_); end
+  def builder_class; end
+  def builder_class=(_); end
+  def headers; end
+  def headers=(_); end
+  def parallel_manager; end
+  def parallel_manager=(_); end
+  def params; end
+  def params=(_); end
+  def proxy; end
+  def proxy=(_); end
+  def request; end
+  def request=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def ssl; end
+  def ssl=(_); end
+  def url; end
+  def url=(_); end
+end
+class Faraday::ConnectionOptions < Anonymous_Faraday_Options_4
+  def builder_class; end
+  def new_builder(block); end
+  def request; end
+  def ssl; end
+end
+class Anonymous_Faraday_Options_5 < Faraday::Options
+  def body; end
+  def body=(_); end
+  def method; end
+  def method=(_); end
+  def parallel_manager; end
+  def parallel_manager=(_); end
+  def params; end
+  def params=(_); end
+  def reason_phrase; end
+  def reason_phrase=(_); end
+  def request; end
+  def request=(_); end
+  def request_headers; end
+  def request_headers=(_); end
+  def response; end
+  def response=(_); end
+  def response_headers; end
+  def response_headers=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def ssl; end
+  def ssl=(_); end
+  def status; end
+  def status=(_); end
+  def url; end
+  def url=(_); end
+end
+class Faraday::Env < Anonymous_Faraday_Options_5
+  def [](key); end
+  def []=(key, value); end
+  def clear_body; end
+  def custom_members; end
+  def in_member_set?(key); end
+  def inspect; end
+  def needs_body?; end
+  def parallel?; end
+  def params_encoder(*args, &block); end
+  def parse_body?; end
+  def self.from(value); end
+  def self.member_set; end
+  def success?; end
+  extend Forwardable
+end
+class Faraday::Connection
+  def adapter(*args, &block); end
+  def app(*args, &block); end
+  def authorization(type, token); end
+  def basic_auth(login, pass); end
+  def build(*args, &block); end
+  def build_exclusive_url(url = nil, params = nil, params_encoder = nil); end
+  def build_request(method); end
+  def build_url(url = nil, extra_params = nil); end
+  def builder; end
+  def default_parallel_manager; end
+  def default_parallel_manager=(arg0); end
+  def delete(url = nil, params = nil, headers = nil); end
+  def dup; end
+  def find_default_proxy; end
+  def get(url = nil, params = nil, headers = nil); end
+  def head(url = nil, params = nil, headers = nil); end
+  def headers; end
+  def headers=(hash); end
+  def host(*args, &block); end
+  def host=(*args, &block); end
+  def in_parallel(manager = nil); end
+  def in_parallel?; end
+  def initialize(url = nil, options = nil); end
+  def options; end
+  def parallel_manager; end
+  def params; end
+  def params=(hash); end
+  def patch(url = nil, body = nil, headers = nil, &block); end
+  def path_prefix(*args, &block); end
+  def path_prefix=(value); end
+  def port(*args, &block); end
+  def port=(*args, &block); end
+  def post(url = nil, body = nil, headers = nil, &block); end
+  def proxy(arg = nil); end
+  def proxy=(new_value); end
+  def proxy_for_request(url); end
+  def proxy_from_env(url); end
+  def put(url = nil, body = nil, headers = nil, &block); end
+  def request(*args, &block); end
+  def response(*args, &block); end
+  def run_request(method, url, body, headers); end
+  def scheme(*args, &block); end
+  def scheme=(*args, &block); end
+  def set_authorization_header(header_type, *args); end
+  def ssl; end
+  def token_auth(token, options = nil); end
+  def url_prefix; end
+  def url_prefix=(url, encoder = nil); end
+  def use(*args, &block); end
+  def with_uri_credentials(uri); end
+  extend Forwardable
+end
+class Faraday::RackBuilder
+  def ==(other); end
+  def [](idx); end
+  def adapter(key, *args, &block); end
+  def adapter_set?; end
+  def app; end
+  def assert_index(index); end
+  def build(options = nil); end
+  def build_env(connection, request); end
+  def build_response(connection, request); end
+  def delete(handler); end
+  def dup; end
+  def handlers; end
+  def handlers=(arg0); end
+  def initialize(handlers = nil); end
+  def insert(index, *args, &block); end
+  def insert_after(index, *args, &block); end
+  def insert_before(index, *args, &block); end
+  def inserting_after_adapter?(index); end
+  def is_adapter?(handler); end
+  def lock!; end
+  def locked?; end
+  def raise_if_locked; end
+  def request(key, *args, &block); end
+  def response(key, *args, &block); end
+  def swap(index, *args, &block); end
+  def to_app(inner_app); end
+  def use(klass, *args, &block); end
+  def use_symbol(mod, key, *args, &block); end
+  def warn_middleware_after_adapter; end
+end
+class Faraday::RackBuilder::StackLocked < RuntimeError
+end
+class Faraday::RackBuilder::Handler
+  def ==(other); end
+  def build(app); end
+  def initialize(klass, *args, &block); end
+  def inspect; end
+  def klass; end
+  def name; end
+end
+module Faraday::NestedParamsEncoder
+  def self.decode(query); end
+  def self.dehash(hash, depth); end
+  def self.encode(params); end
+  def self.escape(*args, &block); end
+  def self.unescape(*args, &block); end
+end
+module Faraday::FlatParamsEncoder
+  def self.decode(query); end
+  def self.encode(params); end
+  def self.escape(*args, &block); end
+  def self.unescape(*args, &block); end
+end
+class Faraday::Middleware
+  def initialize(app = nil); end
+  def self.dependency(lib = nil); end
+  def self.inherited(subclass); end
+  def self.load_error; end
+  def self.load_error=(arg0); end
+  def self.loaded?; end
+  def self.new(*arg0); end
+  extend Faraday::MiddlewareRegistry
+end
+class Faraday::Adapter < Faraday::Middleware
+  def call(env); end
+  def initialize(app = nil, opts = nil, &block); end
+  def save_response(env, status, body, headers = nil, reason_phrase = nil); end
+  extend Faraday::Adapter::Parallelism
+  extend Faraday::AutoloadHelper
+end
+module Faraday::Adapter::Parallelism
+  def inherited(subclass); end
+  def supports_parallel=(arg0); end
+  def supports_parallel?; end
+end
+class Anonymous_Struct_6 < Struct
+  def body; end
+  def body=(_); end
+  def headers; end
+  def headers=(_); end
+  def method; end
+  def method=(_); end
+  def options; end
+  def options=(_); end
+  def params; end
+  def params=(_); end
+  def path; end
+  def path=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Faraday::Request < Anonymous_Struct_6
+  def [](key); end
+  def []=(key, value); end
+  def headers=(hash); end
+  def marshal_dump; end
+  def marshal_load(serialised); end
+  def params=(hash); end
+  def self.create(request_method); end
+  def to_env(connection); end
+  def url(path, params = nil); end
+  extend Faraday::AutoloadHelper
+  extend Faraday::MiddlewareRegistry
+end
+class Faraday::Response
+  def [](*args, &block); end
+  def apply_request(request_env); end
+  def body; end
+  def env; end
+  def finish(env); end
+  def finished?; end
+  def headers; end
+  def initialize(env = nil); end
+  def marshal_dump; end
+  def marshal_load(env); end
+  def on_complete; end
+  def reason_phrase; end
+  def status; end
+  def success?; end
+  def to_hash(*args, &block); end
+  extend Faraday::AutoloadHelper
+  extend Faraday::MiddlewareRegistry
+  extend Forwardable
+end
+class Faraday::Response::Middleware < Faraday::Middleware
+  def call(env); end
+  def on_complete(env); end
+end
+class Faraday::CompositeReadIO
+  def advance_io; end
+  def close; end
+  def current_io; end
+  def ensure_open_and_readable; end
+  def initialize(*parts); end
+  def length; end
+  def read(length = nil, outbuf = nil); end
+  def rewind; end
+end
+class Faraday::Error < StandardError
+end
+class Faraday::ClientError < Faraday::Error
+  def backtrace; end
+  def initialize(ex, response = nil); end
+  def inspect; end
+  def response; end
+  def wrapped_exception; end
+end
+class Faraday::ConnectionFailed < Faraday::ClientError
+end
+class Faraday::ResourceNotFound < Faraday::ClientError
+end
+class Faraday::ParsingError < Faraday::ClientError
+end
+class Faraday::TimeoutError < Faraday::ClientError
+  def initialize(ex = nil); end
+end
+class Faraday::SSLError < Faraday::ClientError
+end
+class Faraday::RetriableResponse < Faraday::ClientError
+end
+module Faraday::AutoloadHelper
+  def all_loaded_constants; end
+  def autoload_all(prefix, options); end
+  def load_autoloaded_constants; end
+end
+module Faraday::MiddlewareRegistry
+  def fetch_middleware(key); end
+  def load_middleware(key); end
+  def lookup_middleware(key); end
+  def middleware_mutex(&block); end
+  def register_middleware(autoload_path = nil, mapping = nil); end
+end
+class Faraday::Request::UrlEncoded < Faraday::Middleware
+  def call(env); end
+  def match_content_type(env); end
+  def process_request?(env); end
+  def request_type(env); end
+  def self.mime_type; end
+  def self.mime_type=(arg0); end
+end
+class Faraday::Request::Multipart < Faraday::Request::UrlEncoded
+  def call(env); end
+  def create_multipart(env, params); end
+  def has_multipart?(obj); end
+  def process_params(params, prefix = nil, pieces = nil, &block); end
+  def process_request?(env); end
+  def unique_boundary; end
+end
+class Faraday::Response::RaiseError < Faraday::Response::Middleware
+  def on_complete(env); end
+  def response_values(env); end
+end