relax2 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3ced21a4e66c7b6eee62f684be2f4960bf10512f9d6618414f5dd6bc750f41a
+  data.tar.gz: 94c2ebd8799612e6dbd780ff5e2eecb65810c4a1b50ec883098ff4e4e7611647
+SHA512:
+  metadata.gz: 7d102b5eb07a687e9fbd92bb9297246d980c0f0101299124a64ed561d1316e351d3e150e72d174846b39fccfc63768580e3db1fc567daa8a7a63548b519165ef
+  data.tar.gz: 76a6bec28e312cafb5ca718aa3109930142fe26dde56cb509613c8ceda521d582357c0a62a3b559ac1458e3bbcbb5e91d72662ac6cb1309b9822583880b2e19b

data/.rubocop.yml

@@ -0,0 +1,29 @@
+require:
+  - rubocop-minitest
+  - rubocop-performance
+
+AllCops:
+  TargetRubyVersion: 2.7
+
+Layout/LineLength:
+  Max: 140
+
+Metrics/AbcSize:
+  Exclude:
+    - 'test/**/*'
+
+Metrics/MethodLength:
+  Max: 16
+
+Style/AccessModifierDeclarations:
+  EnforcedStyle: inline
+
+Style/Documentation:
+  Exclude:
+    - 'test/**/*'
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in relax2.gemspec
+gemspec

data/README.md

@@ -0,0 +1,106 @@
+# Relax2
+
+Relax2 is a quick and dirty HTTP API client factory for Ruby.
+
+```ruby
+## petstore.rb
+require 'relax2'
+
+base_url 'https://petstore.swagger.io/v2'
+
+interceptor -> (request, perform_request) do
+  puts request.body
+  response = perform_request.call(request)
+  puts response.body
+  response
+end
+```
+
+Then enjoy your API calls.
+
+```
+% ruby petstore.rb GET /pet/2
+{
+  "id": 2,
+  "category": {
+    "id": 5,
+    "name": "Angel"
+  },
+  "name": "DOG",
+  "tags": [
+    {
+      "id": 1,
+      "name": "Armanda Hirthe"
+    }
+  ],
+  "status": "available"
+}
+```
+
+```
+% ruby petstore.rb PUT /pet/2
+{
+  "name": "NEW DOG"
+}
+
+{
+  "id": 2,
+  "category": {
+    "id": 5,
+    "name": "Angel"
+  },
+  "name": "NEW DOG",
+  "tags": [
+    {
+      "id": 1,
+      "name": "Armanda Hirthe"
+    }
+  ],
+  "status": "available"
+}
+```
+
+If you want to create more detailed client, use the modular style with `Relax2::Base`.
+
+```ruby
+require 'relax2/base'
+
+class ExampleApi < Relax2::Base
+  base_url 'http://example.com/api/v1'
+
+  interceptor -> (request, perform_request) do
+    puts request.path
+    puts request.body
+    response = perform_request.call(request)
+    puts response.status
+    puts response.body
+    response
+  end
+end
+
+request = Relax2::Request.from_string('GET /hogehoge q=xx USER-Agent: Hoge/1.23')
+response = ExampleApi.call(request)
+```
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'relax2'
+```
+
+and then `bundle install`
+
+## 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 tags, 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/YusukeIwaki/relax2.

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'relax2'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/relax2/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'relax2/dsl'
+require 'relax2/errors'
+require 'relax2/file_cache'
+require 'relax2/fluent_arg'
+require 'relax2/interceptors'
+require 'relax2/request'
+require 'relax2/request_context'
+require 'relax2/response'
+
+module Relax2
+  class Base
+    extend DSL
+
+    def self.call(request)
+      RequestContext.new(base_url: @base_url, interceptors: @interceptors).call(request)
+    end
+
+    def self.run
+      from_pipe = File.pipe?($stdin)
+      from_redirect = !IO.select([$stdin], [], [], 0).nil?
+      body = $stdin.read if from_pipe || from_redirect
+
+      request = Request.from(args: ARGV, body: body)
+
+      @interceptors ||= []
+      @interceptors << Interceptors.print_response if @interceptors.empty?
+
+      call(request)
+    end
+  end
+end

data/lib/relax2/dsl.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Relax2
+  module DSL
+    # @param base_url_value [String]
+    def base_url(base_url_value)
+      @base_url = base_url_value
+    end
+
+    # @param interceptor_impl [Proc|Symbol]
+    def interceptor(interceptor_impl = nil, &interceptor_impl_block)
+      impl =
+        if interceptor_impl_block
+          interceptor_impl_block
+        elsif interceptor_impl.is_a?(Symbol)
+          ::Relax2::Interceptors.send(interceptor_impl)
+        elsif interceptor_impl.respond_to?(:call)
+          interceptor_impl
+        else
+          raise ArgumentError, 'interceptor must be specified as Proc or block'
+        end
+      (@interceptors ||= []) << impl
+    end
+  end
+end

data/lib/relax2/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Relax2
+  class InvalidArgError < RuntimeError
+  end
+end

data/lib/relax2/file_cache.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Relax2
+  class FileCache
+    def initialize(dirname, filename)
+      @cache_dir = cache_dir(dirname)
+      @cache_path = File.join(@cache_dir, filename)
+    end
+
+    private def cache_dir(name)
+      if Gem.win_platform?
+        File.join(Dir.home, 'AppData', 'Roaming', name)
+      else
+        File.join(Dir.home, ".#{name}")
+      end
+    end
+
+    def load
+      File.read(@cache_path) if Dir.exist?(@cache_dir) && File.exist?(@cache_path)
+    end
+
+    def save(data)
+      Dir.mkdir(@cache_dir) unless Dir.exist?(@cache_dir)
+      File.write(@cache_path, data)
+    end
+
+    def clear
+      File.delete(@cache_path) if File.exist?(@cache_path)
+    end
+  end
+end

data/lib/relax2/fluent_arg.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Relax2
+  # @internal
+  class FluentArg
+    NameValuePair = Struct.new(:name, :value) do
+      def initialize(...)
+        super
+        freeze
+      end
+
+      def to_a
+        [name, value]
+      end
+    end
+
+    # @param args [Array<String>] ['GET', '/search', 'q=dart', 'Authorization:' 'Basic' 'aXdha2k6MTIzNDUK']
+    def initialize(args)
+      maybe_http_method, maybe_path_with_query, *maybe_args = args
+      @http_method = validated_http_method_for(maybe_http_method)
+      path_with_query = validated_path_for(maybe_path_with_query)
+      params_and_headers = parse_params_and_headers_from(maybe_args)
+
+      # Merge query parameters
+      uri = URI.parse(path_with_query)
+      @query_parameters = query_parameters_from(uri) + params_and_headers.query_parameters
+      @path = uri.path
+      @headers = params_and_headers.headers
+      @magic_parameters = validated_magic_parameters_from(params_and_headers.magic_parameters)
+    end
+
+    attr_reader :http_method, :path, :query_parameters, :headers, :magic_parameters
+
+    private def validated_http_method_for(maybe_http_method)
+      raise InvalidArgError, 'HTTP method (GET, POST, ...) must be specified' unless Request::SUPPORTED_METHODS.include?(maybe_http_method)
+
+      maybe_http_method
+    end
+
+    private def validated_path_for(maybe_path_with_query)
+      maybe_path_with_query or raise InvalidArgError, 'path must be specified'
+    end
+
+    # @return [Array<Relax2::NameValuePair>]
+    private def query_parameters_from(base_uri)
+      URI.decode_www_form(base_uri.query || '').map do |name, value|
+        NameValuePair.new(name, value)
+      end
+    end
+
+    private def validated_magic_parameters_from(magic_parameters)
+      # Extract @body
+      magic_parameters.each_with_object({}) do |param, result|
+        raise InvalidArgError, "Unknown parameter: #{param.name}" unless param.name == '@body'
+
+        result[:body] = param.value
+      end
+    end
+
+    ParseResult = Struct.new(:query_parameters, :magic_parameters, :headers) do
+      def initialize(...)
+        super
+        freeze
+      end
+    end
+
+    private def match_parameters(arg)
+      if (match = /^(@?[a-zA-Z_]+)=/.match(arg))
+        name = match[1]
+        value = arg[match.end(0)..]
+
+        yield(name, value)
+
+        true
+      else
+        false
+      end
+    end
+
+    private def match_headers(arg)
+      if (match = /^([a-zA-Z_-]+):/.match(arg))
+        name = match[1]
+        value = arg[match.end(0)..]
+
+        yield(name, value)
+
+        true
+      else
+        false
+      end
+    end
+
+    # rubocop:disable Style/AbcSize, Metrics/MethodLength
+    private def parse_params_and_headers_from(maybe_args)
+      query_parameters = []
+      magic_parameters = []
+      headers = []
+      cur = nil
+
+      maybe_args.each do |arg|
+        next if match_parameters(arg) do |name, value|
+          cur =
+            if name.start_with?('@')
+              magic_parameters
+            else
+              query_parameters
+            end
+
+          cur << NameValuePair.new(name, value)
+        end
+
+        next if match_headers(arg) do |name, value|
+          cur = headers
+          cur << NameValuePair.new(name, value)
+        end
+
+        last = cur&.pop or raise InvalidArgError, "Unable to parse args: #{args.join(' ')}"
+        cur << NameValuePair.new(last.name, "#{last.value} #{arg}".lstrip)
+      end
+
+      ParseResult.new(query_parameters, magic_parameters, headers)
+    end
+    # rubocop:enable Style/AbcSize, Metrics/MethodLength
+  end
+end

data/lib/relax2/interceptors.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Relax2
+  module Interceptors
+    class PrintRequest
+      def initialize(print_headers:, print_body:)
+        @print_headers = print_headers
+        @print_body = print_body
+      end
+
+      def call(request, perform_request)
+        lines = []
+        lines << "#{request.http_method} #{request.path}"
+        if @print_headers
+          request.headers.each do |header|
+            lines << "#{header.name}: #{header.value}"
+          end
+        end
+
+        if @print_body && request.body
+          lines << ''
+          lines << request.body
+        end
+
+        puts lines.join("\n")
+        puts ''
+
+        perform_request.call(request)
+      end
+    end
+
+    class PrintResponse
+      def initialize(print_status:, print_headers:)
+        @print_status = print_status
+        @print_headers = print_headers
+      end
+
+      def call(request, perform_request)
+        lines = []
+        response = perform_request.call(request)
+
+        lines << "HTTP #{response.status}" if @print_status
+
+        if @print_headers
+          response.headers.each do |header|
+            lines << "#{header.name}: #{header.value}"
+          end
+        end
+
+        if response.body
+          lines << '' unless lines.empty?
+          lines << response.body
+        end
+        puts lines.join("\n")
+      end
+    end
+
+    module_function def verbose_print_request
+      PrintRequest.new(print_headers: true, print_body: true)
+    end
+
+    module_function def print_response
+      PrintResponse.new(print_status: false, print_headers: false)
+    end
+
+    module_function def verbose_print_response
+      PrintResponse.new(print_status: true, print_headers: true)
+    end
+
+    module_function def json_request
+      lambda do |request, perform_request|
+        request.headers << ['Accept', 'application/json']
+        request.headers << ['Content-Type', 'application/json']
+        perform_request.call(request)
+      end
+    end
+  end
+end

data/lib/relax2/main.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'English'
+module Relax2
+  require 'relax2/base'
+
+  class MainApplication < Base
+  end
+
+  at_exit { MainApplication.run if $ERROR_INFO.nil? }
+end
+
+# Forward DSL methods into MainApplication class.
+# `extend` is important here for defining DSL only into `main` object.
+extend(Module.new do
+  Relax2::DSL.instance_methods(false).each do |method_name|
+    define_method(method_name) do |*args, **kwargs, &block|
+      Relax2::MainApplication.send(method_name, *args, **kwargs, &block)
+    end
+    private method_name
+  end
+end)

data/lib/relax2/request.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Relax2
+  # Stores abstract request intents for building Net::HTTP::Request
+  Request = Struct.new(:http_method, :path, :query_parameters, :headers, :body, keyword_init: true) do
+    # @param args [Array<String>] assumed to be CLI args. ['GET', '/hoge', 'Authorization:', 'Bearer' 'mytopsecret']
+    # @param body [String|nil] assumed to be CLI PIPE input.
+    def self.from(args:, body: nil)
+      arg = FluentArg.new(args)
+
+      raise InvalidArgError, 'STDIN is not acceptable when @body is specified' if arg.magic_parameters[:body] && body
+
+      body = arg.magic_parameters[:body] ? IO.read(arg.magic_parameters[:body]) : body
+
+      new(
+        http_method: arg.http_method,
+        path: arg.path,
+        query_parameters: arg.query_parameters.map(&:to_a),
+        headers: arg.headers.map(&:to_a),
+        body: body,
+      )
+    end
+
+    def initialize(...)
+      super
+      freeze
+    end
+  end
+  Request::SUPPORTED_METHODS = %w[GET POST PUT PATCH DELETE].freeze
+end

data/lib/relax2/request_context.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Relax2
+  class RequestContext
+    def initialize(base_url:, interceptors:)
+      raise InvalidArgError, 'base_url must be specified' unless base_url
+
+      @base_url = base_url
+      @interceptors = interceptors
+    end
+
+    # @param request [Relax2::Request]
+    # @return [Relax2::Response]
+    def call(request)
+      original_method = ActualHttpRequestHandler.new(@base_url)
+      call_with_interceptors = @interceptors.reduce(original_method) do |m, interceptor|
+        ->(req) { interceptor.call(req, m) }
+      end
+      call_with_interceptors.call(request)
+    end
+
+    NET_HTTP_REQUEST_MAP = {
+      'GET' => Net::HTTP::Get,
+      'POST' => Net::HTTP::Post,
+      'PUT' => Net::HTTP::Put,
+      'PATCH' => Net::HTTP::Patch,
+      'DELETE' => Net::HTTP::Delete
+    }.freeze
+
+    class ActualHttpRequestHandler
+      def initialize(base_url)
+        @base_url = base_url
+      end
+
+      # @param [Relax::Request]
+      # @return [Relas2::Response]
+      def call(request)
+        net_http_request = net_http_request_from(request)
+        net_http_response = start_net_http_session do |http|
+          http.request(net_http_request)
+        end
+        response_from(net_http_response)
+      end
+
+      private def start_net_http_session(&block)
+        uri = URI.parse(@base_url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', &block)
+      end
+
+      private def request_uri_from(request)
+        URI.parse("#{@base_url}#{request.path}").tap do |uri|
+          uri.query = URI.encode_www_form(request.query_parameters) unless request.query_parameters.empty?
+        end
+      end
+
+      private def net_http_request_from(request)
+        net_http_request = NET_HTTP_REQUEST_MAP[request.http_method].new(request_uri_from(request))
+
+        request.headers.each do |name, value|
+          net_http_request[name] = value
+        end
+        net_http_request.body = request.body if request.body
+        net_http_request
+      end
+
+      private def response_from(net_http_response)
+        headers = []
+        net_http_response.each_header do |name, value|
+          headers << [name, value]
+        end
+
+        Response.new(
+          status: net_http_response.code.to_i,
+          headers: headers,
+          body: net_http_response.body,
+        )
+      end
+    end
+  end
+end

data/lib/relax2/response.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Relax2
+  Response = Struct.new(:status, :headers, :body, keyword_init: true) do
+    def initialize(...)
+      super
+      freeze
+    end
+  end
+end

data/lib/relax2/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Relax2
+  VERSION = '0.1.0'
+end

data/lib/relax2.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'relax2/main'

data/relax2.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'relax2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'relax2'
+  spec.version       = Relax2::VERSION
+  spec.authors       = ['YusukeIwaki']
+  spec.email         = ['q7w8e9w8q7w8e9@yahoo.co.jp']
+
+  spec.summary       = 'A quick and dirty HTTP API client factory for Ruby'
+  spec.homepage      = 'https://github.com/YusukeIwaki/relax2'
+
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/}) || f.include?('.git')
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.7'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'puma'
+  spec.add_development_dependency 'rack-test_server'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-minitest'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'sinatra'
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: relax2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- YusukeIwaki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test_server
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- q7w8e9w8q7w8e9@yahoo.co.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/relax2.rb
+- lib/relax2/base.rb
+- lib/relax2/dsl.rb
+- lib/relax2/errors.rb
+- lib/relax2/file_cache.rb
+- lib/relax2/fluent_arg.rb
+- lib/relax2/interceptors.rb
+- lib/relax2/main.rb
+- lib/relax2/request.rb
+- lib/relax2/request_context.rb
+- lib/relax2/response.rb
+- lib/relax2/version.rb
+- relax2.gemspec
+homepage: https://github.com/YusukeIwaki/relax2
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: A quick and dirty HTTP API client factory for Ruby
+test_files: []