req_wrap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2c16aacc0cd7adc9fec16b8e873d7110100e24b3272da1646aab602d2980f08b
+  data.tar.gz: 4a2483c368629ec17bcda1d659359c343b7f8b4a417ed46e11015b45b0b4813b
+SHA512:
+  metadata.gz: 83d5b9bc43d7f2e1ae19ed3a569eef39ea5d0a0ee8765e51f4cf8eecb33ab8b7e0dc89fb3094b3d3a017320a303f5400569b7705f5961d71446ef48f1a53cf1e
+  data.tar.gz: 3d01b7721624c66c4f3cf6cb0cdb116a45968bcd5429dda41df3ad5c7b46d6158644b0a01ea390953ff87c6f6280feae2dd415d7fd3a5596f39d107dc0883cff

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-06-10
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 vxd7
+
+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,90 @@
+# ReqWrap
+
+Plain Ruby API client for testing and prototyping with simple environment
+management. Supports encrypted environment definitions. Features optional
+commandline interface and code generation.
+
+## Installation
+
+TODO: Replace
+`UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your
+gem name right after releasing it to RubyGems.org. Please do not do it earlier
+due to security reasons. Alternatively, replace this section with instructions
+to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+Simply subclass `ReqWrap::Req` to use the `HTTP` capabilities of the gem.
+
+### Generate new request template
+
+Simply execute after installing the gem: `req_wrap g my_request`
+
+This will generate the `my_request.rb` file in the current folder with the
+following request template:
+
+```ruby
+# frozen_string_literal: true
+
+require 'req_wrap'
+
+class MyRequest < ReqWrap::Req
+  def call
+    http.get('https://httpbin.org/ip')
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  my_request = MyRequest.new(logger: nil)
+
+  my_request.load_env
+  puts my_request.call
+end
+```
+
+Simply change the definition of the `#call` method and the request can be
+executed like any `Ruby` file: `ruby my_request.rb` which will make the actual
+request and print the results.
+
+The gem provides several quality of life methods which can be used to simplify
+working with requests and responses. Some of these are:
+
+- `#load_env` -- load the request environment
+- `#response` -- reference to the latest `HTTP` response
+- `#executed_request` -- reference to the latest executed `HTTP` request
+- `#responses` -- `Ruby` array with the list of all `HTTP` responses
+- `#save_response` -- save given (or last by default) response to current directory
+
+Additionally, see the `ReqWrap::Req` file definition.
+
+## 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/vxd7/req_wrap
+
+## 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,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/exe/req_wrap

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'req_wrap/cli'
+
+ReqWrap::Cli.new.call(ARGV)

data/lib/req_wrap/cli/environment.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+require 'req_wrap/environment'
+
+module ReqWrap
+  class Cli
+    class Environment
+      DEFAULT_EDITOR = 'vi'
+
+      def initialize
+        @options = {
+          delete_original: false
+        }
+      end
+
+      def call(args) # rubocop:disable Metrics/MethodLength
+        parser = OptionParser.new(banner) do |p|
+          add_gen_pass_option(p)
+          add_enc_option(p)
+          add_change_option(p)
+          add_delete_original_option(p)
+          add_decrypt_option(p)
+
+          p.separator('')
+          p.separator(examples)
+        end
+
+        return parser.parse!(args) unless args.empty?
+
+        puts parser
+        exit(1)
+      end
+
+      private
+
+      def banner
+        <<~BANNER
+          Usage: req_wrap e [options...]
+
+          Manage environment files used by request scripts
+        BANNER
+      end
+
+      def examples
+        <<~EXAMPLES
+          Examples of invocation:
+          - req_wrap e --gen-pass                     # Generate encryption password
+          - req_wrap e --enc env_file.env             # Encrypt environment file env_file.env using generated password
+          - E=env_file.env req_wrap e --enc           # Encrypt environment file env_file.env using generated password
+          - EDITOR=vim req_wrap e --edit env_file.enc # Decrypt environment file, open editor and re-encrypt
+        EXAMPLES
+      end
+
+      def add_gen_pass_option(parser)
+        parser.on('--gen-pass', "Generate password file ('#{ReqWrap::Environment::PASSWORD_FILE}')") do
+          ReqWrap::Environment.generate_password_file
+        end
+      end
+
+      def add_enc_option(parser)
+        desc = 'Encrypt environment file and write the result to env_file.enc file'
+
+        parser.on('--enc [env_file]', desc) do |env_file|
+          ReqWrap::Environment.new(env_file).encrypt(
+            delete_original: @options[:delete_original]
+          )
+        end
+      end
+
+      def add_change_option(parser)
+        desc = 'Edit encrypted environment using supplied text editor'
+
+        parser.on('--change [enc_file]', desc) do |env_file|
+          ReqWrap::Environment.new(env_file).change(ENV.fetch('EDITOR', DEFAULT_EDITOR))
+        end
+      end
+
+      def add_delete_original_option(parser)
+        desc = 'Delete original environment file after encryption'
+
+        parser.on('--delete-original', desc) do
+          @options[:delete_original] = true
+        end
+      end
+
+      def add_decrypt_option(parser)
+        parser.on('--decrypt [env_file]', 'Decrypt env file and print it to stdout') do |env_file|
+          puts ReqWrap::Environment.new(env_file).read
+        end
+      end
+    end
+  end
+end

data/lib/req_wrap/cli/generate.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+require 'req_wrap/generator/req'
+
+module ReqWrap
+  class Cli
+    class Generate
+      def initialize
+        @options = {}
+      end
+
+      def call(args)
+        parser = OptionParser.new(banner) do |p|
+          add_desc_option(p)
+
+          p.separator('')
+          p.separator(examples)
+        end
+
+        parser.parse!(args)
+        return generate_request!(args) unless args.empty?
+
+        puts parser
+        exit(1)
+      end
+
+      private
+
+      def generate_request!(args)
+        request_file = args.shift.strip
+        raise ArgumentError, 'request_file argument cannot be empty' if request_file.empty?
+
+        Generator::Req.new(request_file, @options).call
+      end
+
+      def banner
+        <<~BANNER
+          Usage: req_wrap g [options...] <request_file>
+
+          <request_file> can be either absolute path to filename or relative path.
+          Ruby extension (.rb) is optional.
+
+        BANNER
+      end
+
+      def examples
+        <<~EXAMPLES
+          Examples of invocation:
+          - req_wrap g sample_req             # Create './sample_req.rb' request file
+          - req_wrap g sample_req.rb          # Create './sample_req.rb' request file
+          - req_wrap g requests/sample_req.rb # Create './requests/sample_req.rb' request file
+        EXAMPLES
+      end
+
+      def add_desc_option(parser)
+        option_desc = 'Add optional description to the generated request definition'
+
+        parser.on('-d', '--desc [description]', option_desc) do |request_description|
+          @options[:request_description] = request_description.strip
+        end
+      end
+    end
+  end
+end

data/lib/req_wrap/cli.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+require 'req_wrap/cli/environment'
+require 'req_wrap/cli/generate'
+
+module ReqWrap
+  class Cli
+    COMMAND_ALIASES = {
+      'generate' => %w[g gen],
+      'environment' => %w[e env]
+    }.freeze
+
+    def call(args)
+      arguments = args.dup
+      user_command = arguments.shift
+
+      command = find_command(user_command)
+      return send(command, arguments) if command
+
+      puts common_options
+      exit(1)
+    end
+
+    private
+
+    def common_options
+      OptionParser.new do |parser|
+        parser.on('-h', '--help', 'Show this help message') do
+          puts parser
+          exit
+        end
+
+        parser.separator('')
+        parser.separator(commands_help)
+        parser.separator('')
+        parser.separator(usage_help)
+      end
+    end
+
+    def commands_help
+      commands = COMMAND_ALIASES.map do |command, aliases|
+        aliases_str = aliases.map { |name| "'#{name}'" }.join(', ')
+
+        "- '#{command}' (also aliased as #{aliases_str})"
+      end
+
+      "Available commands:\n#{commands.join("\n")}"
+    end
+
+    def usage_help
+      commands = COMMAND_ALIASES.keys.map do |key|
+        "- req_wrap #{key} --help"
+      end
+
+      "Examples of usage:\n#{commands.join("\n")}"
+    end
+
+    def environment(args)
+      ReqWrap::Cli::Environment.new.call(args)
+    end
+
+    def generate(args)
+      ReqWrap::Cli::Generate.new.call(args)
+    end
+
+    def find_command(user_command)
+      COMMAND_ALIASES.detect do |command_name, command_aliases|
+        user_command == command_name || command_aliases.include?(user_command)
+      end&.first
+    end
+  end
+end

data/lib/req_wrap/environment.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'dotenv'
+require 'tempfile'
+
+require 'active_support'
+require 'active_support/encrypted_file'
+
+module ReqWrap
+  # Request environment
+  #
+  class Environment
+    PASSWORD_FILE = '.reqwrap_password'
+    ENCRYPTED_ENV_FILE_EXT = '.enc'
+
+    def self.generate_password_file
+      path = File.expand_path("./#{PASSWORD_FILE}")
+      raise ArgumentError, 'Password file already exists' if File.exist?(path)
+
+      File.write(path, ActiveSupport::EncryptedFile.generate_key)
+      path
+    end
+
+    def initialize(env_file = nil)
+      @env_file = env_file || default_env_file
+    end
+
+    def encrypted?
+      @env_file.end_with?(ENCRYPTED_ENV_FILE_EXT)
+    end
+
+    def load
+      return unless validate
+
+      load_str_environment(read)
+    end
+
+    def read
+      return decrypt if encrypted?
+
+      File.read(@env_file, mode: 'rb:BOM|utf-8')
+    end
+
+    def write(content)
+      return encrypted_file_for(@env_file).write(content) if encrypted?
+
+      File.write(@env_file, content)
+    end
+
+    def delete
+      File.delete(@env_file) if File.exist?(@env_file)
+    end
+
+    def encrypt(delete_original: false)
+      validate(raise_error: true)
+
+      Environment.new("#{@env_file}#{ENCRYPTED_ENV_FILE_EXT}").write(read)
+      delete if delete_original
+    end
+
+    def change(editor)
+      return change_encrypted_environment(editor) if encrypted?
+
+      Tempfile.create(['', "-#{@env_file}"]) do |tmp_file|
+        original_content = read
+        tmp_file.write(original_content)
+        tmp_file.flush
+
+        launch_external_editor(editor, tmp_file.path)
+
+        tmp_file.rewind
+        new_content = tmp_file.read
+        write(new_content) if original_content != new_content
+      end
+    end
+
+    private
+
+    def change_encrypted_environment(editor)
+      encrypted_file_for(@env_file).change do |decrypted_file_path|
+        launch_external_editor(editor, decrypted_file_path)
+      end
+    end
+
+    def decrypt
+      validate(raise_error: true)
+      encrypted_file_for(@env_file).read
+    end
+
+    # Default env file is given by 'E' environment variable
+    # and will be used by different scripts and classes of this gem;
+    #
+    def default_env_file
+      ENV['E']
+    end
+
+    # Update current environment from supplied
+    # unparsed str
+    #
+    def load_str_environment(environment_str)
+      Dotenv.update(Dotenv::Parser.new(environment_str).call)
+    end
+
+    def encrypted_file_for(content_path)
+      ActiveSupport::EncryptedFile.new(
+        content_path: content_path,
+        key_path: PASSWORD_FILE,
+        env_key: 'REQWRAP_PASSWORD',
+        raise_if_missing_key: true
+      )
+    end
+
+    def validate(raise_error: false)
+      unless @env_file
+        return false unless raise_error
+
+        raise ArgumentError, 'Env file not supplied'
+      end
+
+      unless File.exist?(@env_file)
+        return false unless raise_error
+
+        raise ArgumentError, 'Env file does not exist'
+      end
+
+      true
+    end
+
+    def launch_external_editor(editor, file_path)
+      system(editor, file_path.to_s, exception: true)
+    end
+  end
+end

data/lib/req_wrap/generator/req.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'req_wrap'
+
+<% if request_description -%>
+<%= request_description %>
+<% end -%>
+class <%= request_class_name %> < ReqWrap::Req
+  def call
+    http.get('https://httpbin.org/ip')
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  <%= request_name %> = <%= request_class_name %>.new(logger: nil)
+
+  <%= request_name %>.load_env
+  puts <%= request_name %>.call
+end

data/lib/req_wrap/generator/req.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+require 'active_support'
+require 'active_support/inflector/methods'
+require 'req_wrap/generator/string_wrapper'
+
+module ReqWrap
+  module Generator
+    class Req
+      TEMPLATE = "#{File.dirname(__FILE__)}/req.erb".freeze
+      RUBY_EXT = '.rb'
+
+      def initialize(request_file, options = {})
+        @request_file = ensure_extension(request_file, RUBY_EXT)
+        @request_name = File.basename(@request_file, RUBY_EXT)
+
+        @options = options
+      end
+
+      def call
+        File.write(
+          @request_file,
+          template.result_with_hash(template_options)
+        )
+      end
+
+      private
+
+      def template_options
+        @template_options ||= {
+          request_class_name: ActiveSupport::Inflector.camelize(@request_name),
+          request_name: @request_name,
+          request_description: prepare_request_description
+        }
+      end
+
+      def ensure_extension(file_name, extension)
+        return file_name if file_name.end_with?(extension)
+
+        "#{file_name}#{extension}"
+      end
+
+      def template
+        @template ||= ERB.new(File.read(TEMPLATE), trim_mode: '-').tap do |erb|
+          erb.location = [TEMPLATE, 0]
+        end
+      end
+
+      def prepare_request_description
+        request_description = @options[:request_description]
+        return unless request_description
+        return if request_description.empty?
+
+        lines = StringWrapper.wrap_string(request_description, to: 79)
+        lines << ''
+        lines.map { |line| "# #{line}" }.join("\n")
+      end
+    end
+  end
+end

data/lib/req_wrap/generator/string_wrapper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ReqWrap
+  module Generator
+    module StringWrapper
+      def self.wrap_string(str, to:)
+        wrap_words(str.split(' '), [], to).map { |words| words.join(' ') }
+      end
+
+      def self.wrap_words(words, result, to)
+        # Partitioning is finished if there is nothing more to
+        # partition;
+        #
+        return result if words.empty?
+
+        current_size = 0
+        line, rest = words.partition do |word|
+          current_size += word.size + 1
+          current_size - 1 <= to
+        end
+
+        # Use the next word if wrapping cannot be performed;
+        #
+        # This means that the word length is larger than the 'to'
+        # argument
+        #
+        line << rest.shift if line.empty?
+
+        result << line
+
+        # Continue partitioning the rest of words
+        #
+        wrap_words(rest, result, to)
+      end
+    end
+  end
+end

data/lib/req_wrap/http_features/response_store.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'http'
+
+module ReqWrap
+  module HttpFeatures
+    class ResponseStore < ::HTTP::Feature
+      def initialize(store:)
+        super()
+
+        raise ArgumentError, 'Provide data structure to store responses' unless store
+
+        @store = store
+      end
+
+      def wrap_response(response)
+        @store.append(response)
+
+        response
+      end
+
+      ::HTTP::Options.register_feature(:response_store, self)
+    end
+  end
+end

data/lib/req_wrap/req.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'http'
+
+require 'active_support'
+require 'active_support/inflector/methods'
+
+require 'req_wrap/environment'
+require 'req_wrap/http_features/response_store'
+
+module ReqWrap
+  DEFAULT_LOGGER = Logger.new($stdout)
+
+  class Req
+    attr_reader :responses
+
+    def initialize(timeout: 10, logger: DEFAULT_LOGGER, response_store: [])
+      @timeout = timeout
+      @logger = logger
+      @responses = response_store
+    end
+
+    def load_env
+      Environment.new.load
+    end
+
+    def save_response(response_to_save = response, name: nil)
+      req_class = ActiveSupport::Inflector.underscore(
+        ActiveSupport::Inflector.demodulize(self.class.name)
+      )
+
+      time = Time.now.utc.iso8601(4)
+      filename = [req_class, time, name, 'response.txt'].join('_')
+
+      File.write(filename, response_to_save)
+
+      filename
+    end
+
+    def response
+      @responses.last
+    end
+
+    def executed_request
+      response&.request
+    end
+
+    def to_s
+      response.is_a?(HTTP::Response) ? response.parse : response
+    end
+
+    private
+
+    def e(name)
+      ENV.fetch(name.to_s.upcase)
+    end
+
+    def without_ssl(client)
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      client.default_options = client.default_options.with_ssl_context(ctx)
+      client
+    end
+
+    def http_json
+      http.headers(content_type: 'application/json')
+    end
+
+    def http
+      client = HTTP.timeout(@timeout).use(:auto_inflate)
+      client = client.use(logging: { logger: @logger }) if @logger
+      client = client.use(response_store: { store: @responses }) if @responses
+
+      client
+    end
+  end
+end

data/lib/req_wrap/version.rb

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

data/lib/req_wrap.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'req_wrap/version'
+require 'req_wrap/req'
+
+module ReqWrap
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: req_wrap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- vxd7
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.1.5
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+description: |
+  Plain Ruby API client for testing and prototyping with simple environment management.
+  Supports encrypted environment definitions. Features optional commandline interface and
+  code generation.
+email:
+- vxd732@protonmail.com
+executables:
+- req_wrap
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/req_wrap
+- lib/req_wrap.rb
+- lib/req_wrap/cli.rb
+- lib/req_wrap/cli/environment.rb
+- lib/req_wrap/cli/generate.rb
+- lib/req_wrap/environment.rb
+- lib/req_wrap/generator/req.erb
+- lib/req_wrap/generator/req.rb
+- lib/req_wrap/generator/string_wrapper.rb
+- lib/req_wrap/http_features/response_store.rb
+- lib/req_wrap/req.rb
+- lib/req_wrap/version.rb
+homepage: https://github.com/vxd7/req_wrap
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/vxd7/req_wrap
+  source_code_uri: https://github.com/vxd7/req_wrap
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Simple API client with environment management
+test_files: []