tcr_revived 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a861087ed84e4a776b8ec9f18710eba284c88de8cc0b6db866334a6a01effe8
+  data.tar.gz: 2889aca62e2f9a4612255c42e7ec1c7d316f55cfad008dcc38d4b637fc6681d9
+SHA512:
+  metadata.gz: 7cf287e455aac08c21c3133d81b8df1e4da397735e706e0b28d0eae018e5a91c6fcb7188ec4fb150da858c772fcf6c2a418e5825d35dab5e4f5c76ed2d6dd3e4
+  data.tar.gz: 40105382e6c1c8d100556d41073f67b5e40006b310842a0590f8075aa5a5a99e52142807371d1c99585d9abdb47ae0b136ed647c75fc77337f16c4c5f4f225d8

data/.rubocop.yml

@@ -0,0 +1,34 @@
+inherit_gem:
+  rubocop-espago: rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.6
+  Exclude:
+    - 'spec/**/*'
+
+Gemspec/DependencyVersion:
+  Enabled: false
+
+Style/DocumentationMethod:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/MissingElse:
+  Enabled: false
+
+Security/MarshalLoad:
+  Enabled: false
+
+Style/ImplicitRuntimeError:
+  Enabled: false
+
+Security/YAMLLoad:
+  Enabled: false
+
+Bundler/GemComment:
+  Enabled: false
+
+Bundler/GemVersion:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.1.2

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Change Log
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.3.0] - 2022-10-18
+
+This is the initial version of this fork.
+
+### Changed
+
+- Refactored the code to be more legible
+
+### Added
+
+- Support for Ruby 3.0
+- Support for Ruby 3.1
+- Rubocop configuration
+- GitHub workflow for tests on 4 last major Ruby versions (2.6, 2.7, 3.0, 3.1)

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tcr.gemspec
+gemspec
+
+gem 'bundler-audit'
+gem 'rubocop-espago'
+gem 'solargraph'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rob Forman
+
+MIT License
+
+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,123 @@
+# TCR revived (TCP + VCR)
+
+[![license](https://img.shields.io/badge/License-MIT-purple.svg)](LICENSE)
+[![CI badge](https://github.com/Verseth/tcr_revived/actions/workflows/ci_ruby.yml/badge.svg)](https://github.com/Verseth/tcr_revived/actions/workflows/ci_ruby.yml)
+
+## Why?
+
+The original version of this gem seemed to have been unmaintained at least since 2018.
+
+This fork aims to bring support for Ruby 3.0 and 3.1. It should be a drop-in replacement.
+
+## Original docs
+
+TCR is a *very* lightweight version of [VCR](https://github.com/vcr/vcr) for TCP sockets.
+
+Currently used for recording 'net/smtp', 'net/imap' and 'net/ldap' interactions so only a few of the TCPSocket methods are recorded out.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tcr_revived', require: 'tcr'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tcr_revived
+
+## Usage
+
+```ruby
+require 'test/unit'
+require 'tcr'
+
+TCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/tcr_cassettes'
+  c.hook_tcp_ports = [2525]
+end
+
+class TCRTest < Test::Unit::TestCase
+  def test_example_dot_com
+    TCR.use_cassette('mandrill_smtp') do
+      tcp_socket = TCPSocket.open("smtp.mandrillapp.com", 2525)
+      io = Net::InternetMessageIO.new(tcp_socket)
+      assert_match /220 smtp.mandrillapp.com ESMTP/, io.readline
+    end
+  end
+end
+```
+
+Run this test once, and TCR will record the tcp interactions to fixtures/tcr_cassettes/google_smtp.json.
+
+```json
+[
+  [
+    [
+      "read",
+      "220 smtp.mandrillapp.com ESMTP\r\n"
+    ]
+  ]
+]
+```
+
+Run it again, and TCR will replay the interactions from json when the tcp request is made. This test is now fast (no real TCP requests are made anymore), deterministic and accurate.
+
+You can disable TCR hooking TCPSocket ports for a given block via `turned_off`:
+
+```ruby
+TCR.turned_off do
+  tcp_socket = TCPSocket.open("smtp.mandrillapp.com", 2525)
+end
+```
+
+To make sure all external calls really happened use `hit_all` option:
+
+```ruby
+class TCRTest < Test::Unit::TestCase
+  def test_example_dot_com
+    TCR.use_cassette('mandrill_smtp', hit_all: true) do
+      # There are previously recorded external calls.
+      # ExtraSessionsError will be raised as a result.
+    end
+  end
+end
+```
+
+You can also use the configuration option:
+
+```ruby
+TCR.configure do |c|
+  c.hit_all = true
+end
+```
+
+The following storage formats are supported:
+
+- JSON (default)
+- YAML
+- Marshal (recommended for binary data transfer like LDAP)
+
+You can configure them via:
+
+```ruby
+TCR.configure do |c|
+  c.format = 'json'
+  # or
+  c.format = 'yaml'
+  # or
+  c.format = 'marshal'
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+::RSpec::Core::RakeTask.new('spec')
+
+task default: :spec

data/lib/tcr/cassette.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module TCR
+  class Cassette
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+
+      if recording?
+        verify_cassette_path_is_writable
+        @sessions = []
+      else
+        @sessions = unmarshal(File.read(filename))
+      end
+    end
+
+    def recording?
+      @recording ||= !File.exist?(filename)
+    end
+
+    def next_session
+      if recording?
+        @sessions << []
+        @sessions.last
+      else
+        raise NoMoreSessionsError if @sessions.empty?
+
+        @sessions.shift
+      end
+    end
+
+    def save
+      return unless recording?
+
+      File.write(filename, marshal(@sessions))
+    rescue Encoding::UndefinedConversionError
+      File.binwrite(filename, marshal(@sessions))
+    end
+
+    def check_hits_all_sessions
+      raise ExtraSessionsError if !recording? && !@sessions.empty?
+    end
+
+    protected
+
+    def unmarshal(content)
+      case TCR.configuration.format
+      when 'json'
+        JSON.parse(content)
+      when 'yaml'
+        YAML.load(content)
+      when 'marshal'
+        Marshal.load(content)
+      else
+        raise "unrecognized cassette format '#{TCR.configuration.format}'; " \
+              "please use one of 'json', 'yaml', or 'marshal'"
+      end
+    end
+
+    def marshal(content)
+      case TCR.configuration.format
+      when 'json'
+        JSON.pretty_generate(content)
+      when 'yaml'
+        YAML.dump(content)
+      when 'marshal'
+        Marshal.dump(content)
+      else
+        raise "unrecognized cassette format '#{TCR.configuration.format}'; " \
+              "please use one of 'json', 'yaml', or 'marshal'"
+      end
+    end
+
+    # @return [String]
+    def filename
+      ::File.expand_path("#{name}.#{TCR.configuration.format}", TCR.configuration.cassette_library_dir.to_s)
+    end
+
+    def verify_cassette_path_is_writable
+      FileUtils.mkdir_p(File.dirname(filename))
+      FileUtils.touch(filename)
+    end
+  end
+end

data/lib/tcr/configuration.rb

@@ -0,0 +1,21 @@
+# rubocop:disable Style/FrozenStringLiteralComment
+
+module TCR
+  class Configuration
+    attr_accessor :cassette_library_dir, :hook_tcp_ports, :block_for_reads, :format, :hit_all
+
+    def initialize
+      reset_defaults!
+    end
+
+    def reset_defaults!
+      @cassette_library_dir = 'fixtures/tcr_cassettes'
+      @hook_tcp_ports = []
+      @block_for_reads = false
+      @format = 'json'
+      @hit_all = false
+    end
+  end
+end
+
+# rubocop:enable Style/FrozenStringLiteralComment

data/lib/tcr/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module TCR
+  class TCRError < StandardError; end
+  class NoCassetteError < TCRError; end
+  class NoMoreSessionsError < TCRError; end
+  class ExtraSessionsError < TCRError; end
+  class DirectionMismatchError < TCRError; end
+end

data/lib/tcr/net/ldap.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# support LDAP(S) connections
+if defined? ::Net::LDAP
+
+  module Net::LDAP::Connection::FixSSLSocketSyncClose
+    def close
+      super
+      # see: https://github.com/ruby-ldap/ruby-net-ldap/pull/314
+      return if io.closed?
+
+      io.close
+    end
+  end
+
+  module TCR
+    class RecordableTCPSocket
+      include Net::LDAP::Connection::GetbyteForSSLSocket
+      include Net::BER::BERParser
+    end
+  end
+end

data/lib/tcr/recordable_tcp_socket.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'openssl'
+module TCR
+  class RecordableTCPSocket
+    attr_reader :live, :socket, :recording
+
+    def initialize(address, port, cassette)
+      raise TCR::NoCassetteError unless TCR.cassette
+
+      @read_lock = []
+      @recording = cassette.next_session
+      @live = cassette.recording?
+      @config_block_for_reads = TCR.configuration.block_for_reads
+
+      if live
+        begin
+          @socket = TCPSocket.real_open(address, port)
+        rescue StandardError => e
+          recording << ['error', Marshal.dump(e)]
+          raise
+        end
+      else
+        @closed = false
+        check_recording_for_errors
+      end
+    end
+
+    # no-op for Ruby 3.1 compatibility
+    def hostname=(*args); end
+
+    def read(bytes)
+      _read(:read, bytes)
+    end
+
+    def getc(*args)
+      _read(:getc, *args)
+    end
+
+    def gets(*args)
+      _read(:gets, *args)
+    end
+
+    def read_nonblock(*args, **_rest)
+      _read(:read_nonblock, *args, blocking: false)
+    end
+
+    def print(str)
+      _write(:print, str)
+    end
+
+    def write(str)
+      _write(:write, str)
+      str.length
+    end
+
+    def write_nonblock(str, *_rest)
+      _write(:write_nonblock, str)
+      str.length
+    end
+
+    def ssl_version; end
+
+    def cipher
+      {}
+    end
+
+    def to_io
+      @socket.to_io if live
+    end
+
+    def closed?
+      if live
+        @socket.closed?
+      else
+        @closed
+      end
+    end
+
+    def close
+      if live
+        @socket.close
+      else
+        @closed = true
+      end
+    end
+
+    def setsockopt(*args); end
+
+    private
+
+    attr_reader :config_block_for_reads
+
+    def check_recording_for_errors
+      raise Marshal.load(recording.first.last) if recording.first.first == 'error'
+    end
+
+    def _intercept_socket
+      @socket = yield @socket if @socket
+    end
+
+    def _block_for_read_data
+      @read_lock.pop while recording.first && recording.first.first != 'read'
+    end
+
+    def _check_for_blocked_reads
+      @read_lock << 1
+    end
+
+    def _write(method, data)
+      if live
+        payload = data.dup unless data.is_a?(Symbol)
+        @socket.__send__(method, payload)
+        recording << ['write', data.dup]
+      else
+        direction, = recording.shift
+        _ensure_direction('write', direction) if direction
+        _check_for_blocked_reads
+      end
+    end
+
+    def _read(method, *args, blocking: true)
+      if live
+        data    = @socket.__send__(method, *args)
+        payload = data.dup unless data.is_a?(Symbol)
+        recording << ['read', payload]
+      else
+        _block_for_read_data if blocking && config_block_for_reads
+        raise EOFError if recording.empty?
+
+        direction, data = recording.shift
+        _ensure_direction('read', direction)
+      end
+      data
+    rescue IO::EAGAINWaitReadable, OpenSSL::SSL::SSLErrorWaitReadable
+      retry
+    end
+
+    def _ensure_direction(desired, actual)
+      return if desired == actual
+
+      raise TCR::DirectionMismatchError, "Expected to '#{desired}' but next in recording was '#{actual}'"
+    end
+  end
+
+  class RecordableSSLSocket < SimpleDelegator
+    def initialize(tcr_socket)
+      super(tcr_socket)
+      tcr_socket.__send__(:_intercept_socket) do |sock|
+        socket = OpenSSL::SSL::SSLSocket.new(sock, OpenSSL::SSL::SSLContext.new)
+        socket.sync_close = true
+        socket.connect
+        socket
+      end
+    end
+
+    def sync_close=(_arg)
+      true
+    end
+
+    def sync
+      self
+    end
+
+    def sync=(_arg)
+      self
+    end
+
+    def flush
+      self
+    end
+
+    def session
+      self
+    end
+
+    def session=(args); end
+
+    def io
+      self
+    end
+
+    def shutdown
+      socket.io.shutdown if live
+    end
+
+    def connect_nonblock(*)
+      self
+    end
+
+    def connect
+      self
+    end
+
+    def post_connection_check(*_args)
+      true
+    end
+  end
+end

data/lib/tcr/version.rb

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

data/lib/tcr.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'tcr/cassette'
+require 'tcr/configuration'
+require 'tcr/errors'
+require 'tcr/recordable_tcp_socket'
+require 'tcr/version'
+require 'socket'
+require 'json'
+
+
+module TCR
+  extend self
+
+  def configure
+    yield configuration
+  end
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def cassette
+    @cassette
+  end
+
+  def cassette=(val)
+    @cassette = val
+  end
+
+  def disabled
+    @disabled || false
+  end
+
+  def disabled=(val)
+    @disabled = val
+  end
+
+  def save_session; end
+
+  def use_cassette(name, options = {}, &block)
+    raise ArgumentError, '`TCR.use_cassette` requires a block.' unless block
+
+    TCR.cassette = Cassette.new(name)
+    yield
+    TCR.cassette.save
+    TCR.cassette.check_hits_all_sessions if options[:hit_all] || configuration.hit_all
+  ensure
+    TCR.cassette = nil
+  end
+
+  def turned_off(&block)
+    raise ArgumentError, '`TCR.turned_off` requires a block.' unless block
+
+    current_hook_tcp_ports = configuration.hook_tcp_ports
+    configuration.hook_tcp_ports = []
+    yield
+    configuration.hook_tcp_ports = current_hook_tcp_ports
+  end
+end
+
+# The monkey patch shim
+class TCPSocket
+  class << self
+    alias_method :real_open,  :open
+
+    def open(address, port, *_args)
+      if TCR.configuration.hook_tcp_ports.include?(port)
+        TCR::RecordableTCPSocket.new(address, port, TCR.cassette)
+      else
+        real_open(address, port)
+      end
+    end
+  end
+end
+
+class OpenSSL::SSL::SSLSocket # rubocop:disable Style/StaticClass
+  class << self
+    def new(io, *args)
+      if io.is_a?(TCR::RecordableTCPSocket)
+        TCR::RecordableSSLSocket.new(io)
+      else
+        super
+      end
+    end
+  end
+end
+
+class Socket
+  class << self
+    alias_method :real_tcp, :tcp
+
+    def tcp(host, port, *socket_opts)
+      if TCR.configuration.hook_tcp_ports.include?(port)
+        TCR::RecordableTCPSocket.new(host, port, TCR.cassette)
+      else
+        real_tcp(host, port, *socket_opts)
+      end
+    end
+  end
+end

data/tcr_revived.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+lib = ::File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tcr/version'
+
+::Gem::Specification.new do |gem|
+  gem.name          = 'tcr_revived'
+  gem.version       = ::TCR::VERSION
+  gem.authors       = ['Rob Forman', 'Mateusz Drewniak']
+  gem.email         = ['rob@robforman.com', 'matmg24@gmail.com']
+  gem.description   = 'TCR is a lightweight VCR for TCP sockets.'
+  gem.summary       = 'TCR is a lightweight VCR for TCP sockets.'
+  gem.homepage      = 'https://github.com/Verseth/tcr'
+  gem.license = 'MIT'
+
+  gem.metadata['homepage_uri'] = gem.homepage
+  gem.metadata['source_code_uri'] = gem.homepage
+  gem.metadata['rubygems_mfa_required'] = 'true'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  gem.files = ::Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  gem.bindir = 'exe'
+  gem.executables = gem.files.grep(%r{\Aexe/}) { |f| ::File.basename(f) }
+  gem.require_paths = ['lib']
+  gem.required_ruby_version = '>= 2.6.10'
+
+  gem.add_development_dependency 'debug'
+  gem.add_development_dependency 'geminabox'
+  gem.add_development_dependency 'mail'
+  gem.add_development_dependency 'mime-types', '~>2.0'
+  gem.add_development_dependency 'net-imap'
+  gem.add_development_dependency 'net-ldap'
+  gem.add_development_dependency 'net-pop'
+  gem.add_development_dependency 'net-smtp'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: tcr_revived
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Rob Forman
+- Mateusz Drewniak
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debug
+  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: geminabox
+  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: mail
+  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: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: net-imap
+  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: net-ldap
+  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: net-pop
+  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: net-smtp
+  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: rspec
+  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: TCR is a lightweight VCR for TCP sockets.
+email:
+- rob@robforman.com
+- matmg24@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tcr.rb
+- lib/tcr/cassette.rb
+- lib/tcr/configuration.rb
+- lib/tcr/errors.rb
+- lib/tcr/net/ldap.rb
+- lib/tcr/recordable_tcp_socket.rb
+- lib/tcr/version.rb
+- tcr_revived.gemspec
+homepage: https://github.com/Verseth/tcr
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Verseth/tcr
+  source_code_uri: https://github.com/Verseth/tcr
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.10
+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: TCR is a lightweight VCR for TCP sockets.
+test_files: []