tcp-client 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02440fe17a1480ba18bec8b6918cea6420a065d997c423a6602e165e0f316564
-  data.tar.gz: 73e315f2c80a2f0f1cf0cb57b24f2f2cd45e10caffebd83dd47510ea85de1f25
+  metadata.gz: 91bdfe4046f3e4baeefe4a140d7a2bdb0cac02d3c069102e9c574fe02e5ca1c8
+  data.tar.gz: e26cc5ce187d50aba43d06403730445f3605667a4cffc5d4c7105dd549ca4c9a
 SHA512:
-  metadata.gz: bb22bb974aacd8cfc9d4a1ebcc66393172ec949db8038ecbc37c1a4187bb8a1d703206625f25fb7dba5e336217d2de31475220aa4147bc20df26a5deff7bd7b7
-  data.tar.gz: 0fd048dda8d10ba76659276cd7f5c09e1fba73560d482a5cbbb35ba6db034192137552531dcd294d45a50a10a211839b318015d0546ded7df28c8f55246fe7fd
+  metadata.gz: dfc647093949536fa3c040f9140ec5039a37934e1b77ccc3150f9c16a8de824123c7e8b374faa9479c5572a84f7cb9e08a051e356fe76e79d9245e10efd61bf4
+  data.tar.gz: 6046435c921660e284838c0e33559540f81de5f8b4c150ab63bf37ee72fc7605bc128d5c2b79d8ac7cb6cf657267bc445a4bef36103508ffaed4d6b0961d023c

data/README.md

@@ -61,7 +61,7 @@ To install the gem globally use:
 gem install tcp-client
 ```
 
-After that you need only a single line of code in your project to have all tools on board:
+After that you need only a single line of code in your project to have on board:
 
 ```ruby
 require 'tcp-client'

data/lib/tcp-client/configuration.rb

@@ -30,40 +30,25 @@ class TCPClient
     #
     # @return [Configuration] the initialized configuration
     #
-    def self.create(options = {})
+    def self.create(options = nil)
       configuration = new(options)
       yield(configuration) if block_given?
       configuration
     end
 
     #
-    # Initializes the instance with given options.
+    # Initializes and optionally configures the instance with given options.
     #
-    # @param options [{Symbol => Object}]
-    # @option options [Boolean] :buffered, see {#buffered}
-    # @option options [Boolean] :keep_alive, see {#keep_alive}
-    # @option options [Boolean] :reverse_lookup, see {#reverse_lookup}
-    # @option options [{Symbol => Object}] :ssl_params, see {#ssl_params}
-    # @option options [Numeric] :connect_timeout, see {#connect_timeout}
-    # @option options [Class<Exception>] :connect_timeout_error, see
-    #   {#connect_timeout_error}
-    # @option options [Numeric] :read_timeout, see {#read_timeout}
-    # @option options [Class<Exception>] :read_timeout_error, see
-    #   {#read_timeout_error}
-    # @option options [Numeric] :write_timeout, see {#write_timeout}
-    # @option options [Class<Exception>] :write_timeout_error, see
-    #   {#write_timeout_error}
-    # @option options [Boolean] :normalize_network_errors, see
-    #   {#normalize_network_errors}
+    # @see #configure
     #
-    def initialize(options = {})
+    def initialize(options = nil)
       @buffered = @keep_alive = @reverse_lookup = true
       self.timeout = @ssl_params = nil
       @connect_timeout_error = ConnectTimeoutError
       @read_timeout_error = ReadTimeoutError
       @write_timeout_error = WriteTimeoutError
       @normalize_network_errors = false
-      options.each_pair { |attribute, value| set(attribute, value) }
+      configure(options) if options
     end
 
     # @!group Instance Attributes Socket Level
@@ -257,6 +242,8 @@ class TCPClient
 
     # @!endgroup
 
+    # @!group Other Instance Attributes
+
     #
     # Enables/disables if network exceptions should be raised as {NetworkError}.
     #
@@ -274,10 +261,12 @@ class TCPClient
       @normalize_network_errors = value ? true : false
     end
 
+    # @!endgroup
+
     #
     # @return [{Symbol => Object}] Hash containing all attributes
     #
-    # @see #initialize
+    # @see #configure
     #
     def to_h
       {
@@ -295,6 +284,33 @@ class TCPClient
       }
     end
 
+    #
+    # Configures the instance with given options Hash.
+    #
+    # @param options [{Symbol => Object}]
+    # @option options [Boolean] :buffered, see {#buffered}
+    # @option options [Boolean] :keep_alive, see {#keep_alive}
+    # @option options [Boolean] :reverse_lookup, see {#reverse_lookup}
+    # @option options [{Symbol => Object}] :ssl_params, see {#ssl_params}
+    # @option options [Numeric] :connect_timeout, see {#connect_timeout}
+    # @option options [Class<Exception>] :connect_timeout_error, see
+    #   {#connect_timeout_error}
+    # @option options [Numeric] :read_timeout, see {#read_timeout}
+    # @option options [Class<Exception>] :read_timeout_error, see
+    #   {#read_timeout_error}
+    # @option options [Numeric] :write_timeout, see {#write_timeout}
+    # @option options [Class<Exception>] :write_timeout_error, see
+    #   {#write_timeout_error}
+    # @option options [Boolean] :normalize_network_errors, see
+    #   {#normalize_network_errors}
+    #
+    # @return [Configuration] self
+    #
+    def configure(options)
+      options.each_pair { |attribute, value| set(attribute, value) }
+      self
+    end
+
     # @!visibility private
     def freeze
       @ssl_params.freeze

data/lib/tcp-client/default_configuration.rb

@@ -25,13 +25,13 @@ class TCPClient
     #     cfg.ssl_params = { min_version: :TLS1_2, max_version: :TLS1_3 }
     #   end
     #
-    # @param options [Hash] see {Configuration#initialize} for details
+    # @param options [Hash] see {Configuration#configure} for details
     #
     # @yieldparam cfg {Configuration} the new configuration
     #
     # @return [Configuration] the new default configuration
     #
-    def configure(options = {}, &block)
+    def configure(options = nil, &block)
       @default_configuration = Configuration.create(options, &block)
     end
   end

data/lib/tcp-client/mixin/io_with_deadline.rb

@@ -4,40 +4,35 @@ class TCPClient
   module IOWithDeadlineMixin
     def self.included(mod)
       methods = mod.instance_methods
-      if methods.index(:wait_writable) && methods.index(:wait_readable)
-        mod.include(ViaWaitMethod)
-      elsif methods.index(:to_io)
-        mod.include(ViaIOWaitMethod)
-      else
-        mod.include(ViaSelect)
-      end
+      return if methods.index(:wait_writable) && methods.index(:wait_readable)
+      mod.include(methods.index(:to_io) ? WaitWithIO : WaitWithSelect)
     end
 
     def read_with_deadline(nbytes, deadline, exception)
       raise(exception) unless deadline.remaining_time
       return fetch_avail(deadline, exception) if nbytes.nil?
       return ''.b if nbytes.zero?
-      @buf ||= ''.b
-      while @buf.bytesize < nbytes
-        read = fetch_next(deadline, exception) and next @buf << read
+      @read_buffer ||= ''.b
+      while @read_buffer.bytesize < nbytes
+        read = fetch_next(deadline, exception) and next @read_buffer << read
         close
         break
       end
-      fetch_buffer_slice(nbytes)
+      fetch_slice(nbytes)
     end
 
-    def readto_with_deadline(sep, deadline, exception)
+    def read_to_with_deadline(sep, deadline, exception)
       raise(exception) unless deadline.remaining_time
-      @buf ||= ''.b
-      while (index = @buf.index(sep)).nil?
-        read = fetch_next(deadline, exception) and next @buf << read
+      @read_buffer ||= ''.b
+      while @read_buffer.index(sep).nil?
+        read = fetch_next(deadline, exception) and next @read_buffer << read
         close
         break
       end
-      index = @buf.index(sep)
-      return fetch_buffer_slice(index + sep.bytesize) if index
-      result = @buf
-      @buf = nil
+      index = @read_buffer.index(sep)
+      return fetch_slice(index + sep.bytesize) if index
+      result = @read_buffer
+      @read_buffer = nil
       result
     end
 
@@ -58,20 +53,18 @@ class TCPClient
     private
 
     def fetch_avail(deadline, exception)
-      if @buf.nil?
-        result = fetch_next(deadline, exception) and return result
+      if (result = @read_buffer || fetch_next(deadline, exception)).nil?
         close
         return ''.b
       end
-      result = @buf
-      @buf = nil
+      @read_buffer = nil
       result
     end
 
-    def fetch_buffer_slice(size)
-      result = @buf.byteslice(0, size)
-      rest = @buf.bytesize - result.bytesize
-      @buf = rest.zero? ? nil : @buf.byteslice(size, rest)
+    def fetch_slice(size)
+      result = @read_buffer.byteslice(0, size)
+      rest = @read_buffer.bytesize - result.bytesize
+      @read_buffer = rest.zero? ? nil : @read_buffer.byteslice(size, rest)
       result
     end
 
@@ -81,68 +74,44 @@ class TCPClient
       end
     end
 
-    module ViaWaitMethod
-      private def with_deadline(deadline, exception)
-        loop do
-          case ret = yield
-          when :wait_writable
-            remaining_time = deadline.remaining_time or raise(exception)
-            raise(exception) if wait_writable(remaining_time).nil?
-          when :wait_readable
-            remaining_time = deadline.remaining_time or raise(exception)
-            raise(exception) if wait_readable(remaining_time).nil?
-          else
-            return ret
-          end
+    def with_deadline(deadline, exception)
+      loop do
+        case ret = yield
+        when :wait_writable
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if wait_writable(remaining_time).nil?
+        when :wait_readable
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if wait_readable(remaining_time).nil?
+        else
+          return ret
         end
-      rescue Errno::ETIMEDOUT
-        raise(exception)
       end
+    rescue Errno::ETIMEDOUT
+      raise(exception)
     end
 
-    module ViaIOWaitMethod
-      private def with_deadline(deadline, exception)
-        loop do
-          case ret = yield
-          when :wait_writable
-            remaining_time = deadline.remaining_time or raise(exception)
-            raise(exception) if to_io.wait_writable(remaining_time).nil?
-          when :wait_readable
-            remaining_time = deadline.remaining_time or raise(exception)
-            raise(exception) if to_io.wait_readable(remaining_time).nil?
-          else
-            return ret
-          end
-        end
-      rescue Errno::ETIMEDOUT
-        raise(exception)
+    module WaitWithIO
+      def wait_writable(remaining_time)
+        to_io.wait_writable(remaining_time)
+      end
+
+      def wait_readable(remaining_time)
+        to_io.wait_readable(remaining_time)
       end
     end
 
-    module ViaSelect
-      private def with_deadline(deadline, exception)
-        loop do
-          case ret = yield
-          when :wait_writable
-            remaining_time = deadline.remaining_time or raise(exception)
-            if ::IO.select(nil, [self], nil, remaining_time).nil?
-              raise(exception)
-            end
-          when :wait_readable
-            remaining_time = deadline.remaining_time or raise(exception)
-            if ::IO.select([self], nil, nil, remaining_time).nil?
-              raise(exception)
-            end
-          else
-            return ret
-          end
-        end
-      rescue Errno::ETIMEDOUT
-        raise(exception)
+    module WaitWithSelect
+      def wait_writable(remaining_time)
+        ::IO.select(nil, [self], nil, remaining_time)
+      end
+
+      def wait_readable(remaining_time)
+        ::IO.select([self], nil, nil, remaining_time)
       end
     end
 
-    private_constant(:ViaWaitMethod, :ViaIOWaitMethod, :ViaSelect)
+    private_constant(:WaitWithIO, :WaitWithSelect)
   end
 
   private_constant(:IOWithDeadlineMixin)

data/lib/tcp-client/version.rb

@@ -2,5 +2,5 @@
 
 class TCPClient
   # The current version number.
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
 end

data/lib/tcp-client.rb

@@ -231,7 +231,7 @@ class TCPClient
     exception ||= configuration.read_timeout_error
     line =
       stem_errors(exception) do
-        @socket.readto_with_deadline(separator, deadline, exception)
+        @socket.read_to_with_deadline(separator, deadline, exception)
       end
     chomp ? line.chomp : line
   end
@@ -344,7 +344,8 @@ class TCPClient
       IOError,
       SocketError
     ].tap do |errors|
-      errors << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
-    end.freeze
+        errors << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
+      end
+      .freeze
   private_constant(:NETWORK_ERRORS)
 end

data/rakefile.rb

@@ -7,12 +7,10 @@ require 'yard'
 
 $stdout.sync = $stderr.sync = true
 
-CLEAN << 'prj' << 'doc'
-
-CLOBBER << '.yardoc'
+CLEAN << '.yardoc'
+CLOBBER << 'prj' << 'doc'
 
 task(:default) { exec('rake --tasks') }
-
+task(test: :spec)
 RSpec::Core::RakeTask.new { |task| task.ruby_opts = %w[-w] }
-
 YARD::Rake::YardocTask.new { |task| task.stats_options = %w[--list-undoc] }

data/sample/google_ssl.rb

@@ -22,7 +22,7 @@ cfg =
 response =
   TCPClient.with_deadline(1.5, 'www.google.com:443', cfg) do |client|
     client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n") #=> 40
-    client.readline("\r\n\r\n") #=> see response
+    client.readline("\r\n\r\n") #=> header, see response
   end
 
 puts(response)

data/spec/tcp-client/configuration_spec.rb

@@ -60,20 +60,34 @@ RSpec.describe TCPClient::Configuration do
       end
     end
 
-    context 'with valid options' do
-      subject(:configuration) do
-        TCPClient::Configuration.new(
-          buffered: false,
-          keep_alive: false,
-          reverse_lookup: false,
-          normalize_network_errors: true,
-          ssl: true,
-          timeout: 60,
-          timeout_error: custom_error
-        )
+    context 'when options are given' do
+      let(:options) { double(:options) }
+
+      it 'calls #configure with given options' do
+        expect_any_instance_of(TCPClient::Configuration).to receive(
+          :configure
+        ).once.with(options)
+
+        TCPClient::Configuration.new(options)
       end
-      let(:custom_error) { Class.new(StandardError) }
+    end
+  end
+
+  describe '#configure' do
+    subject(:configuration) do
+      TCPClient::Configuration.new.configure(
+        buffered: false,
+        keep_alive: false,
+        reverse_lookup: false,
+        normalize_network_errors: true,
+        ssl: true,
+        timeout: 60,
+        timeout_error: custom_error
+      )
+    end
+    let(:custom_error) { Class.new(StandardError) }
 
+    context 'with valid options' do
       it 'allows to configure buffering' do
         expect(configuration.buffered).to be false
       end
@@ -107,52 +121,56 @@ RSpec.describe TCPClient::Configuration do
       end
 
       it 'allows to configure dedicated timeout values' do
-        config =
-          TCPClient::Configuration.new(
-            connect_timeout: 21,
-            read_timeout: 42,
-            write_timeout: 84
-          )
-        expect(config.connect_timeout).to be 21
-        expect(config.read_timeout).to be 42
-        expect(config.write_timeout).to be 84
+        configuration.configure(
+          connect_timeout: 21,
+          read_timeout: 42,
+          write_timeout: 84
+        )
+        expect(configuration.connect_timeout).to be 21
+        expect(configuration.read_timeout).to be 42
+        expect(configuration.write_timeout).to be 84
       end
 
       it 'allows to configure dedicated timeout errors' do
         custom_connect = Class.new(StandardError)
         custom_read = Class.new(StandardError)
         custom_write = Class.new(StandardError)
-        config =
-          TCPClient::Configuration.new(
-            connect_timeout_error: custom_connect,
-            read_timeout_error: custom_read,
-            write_timeout_error: custom_write
-          )
-        expect(config.connect_timeout_error).to be custom_connect
-        expect(config.read_timeout_error).to be custom_read
-        expect(config.write_timeout_error).to be custom_write
+        configuration.configure(
+          connect_timeout_error: custom_connect,
+          read_timeout_error: custom_read,
+          write_timeout_error: custom_write
+        )
+        expect(configuration.connect_timeout_error).to be custom_connect
+        expect(configuration.read_timeout_error).to be custom_read
+        expect(configuration.write_timeout_error).to be custom_write
       end
+    end
 
-      it 'raises when no exception class is used to configure a timeout error' do
-        expect do
-          TCPClient::Configuration.new(
-            connect_timeout_error: double(:something)
-          )
-        end.to raise_error(TCPClient::NotAnExceptionError)
+    context 'when an invalid attribute is given' do
+      it 'raises an error' do
+        expect { configuration.configure(invalid: :value) }.to raise_error(
+          TCPClient::UnknownAttributeError
+        )
+      end
+    end
+
+    context 'when no exception class is used to configure a timeout error' do
+      it 'raises with invalid connect_timeout_error' do
         expect do
-          TCPClient::Configuration.new(read_timeout_error: double(:something))
+          configuration.configure(connect_timeout_error: double(:something))
         end.to raise_error(TCPClient::NotAnExceptionError)
+      end
+
+      it 'raises with invalid read_timeout_error' do
         expect do
-          TCPClient::Configuration.new(write_timeout_error: double(:something))
+          configuration.configure(read_timeout_error: double(:something))
         end.to raise_error(TCPClient::NotAnExceptionError)
       end
-    end
 
-    context 'with invalid attribute' do
-      it 'raises an error' do
-        expect { TCPClient::Configuration.new(invalid: :value) }.to raise_error(
-          TCPClient::UnknownAttributeError
-        )
+      it 'raises with invalid write_timeout_error' do
+        expect do
+          configuration.configure(write_timeout_error: double(:something))
+        end.to raise_error(TCPClient::NotAnExceptionError)
       end
     end
   end

data/spec/tcp-client/default_configuration_spec.rb

@@ -9,8 +9,9 @@ RSpec.describe 'TCPClient.configure' do
 
   context 'called with parameters' do
     it 'creates a new configuratiion' do
-      expect(TCPClient::Configuration).to receive(:create).once.with(a: 1, b: 2)
-      TCPClient.configure(a: 1, b: 2)
+      options = double(:options)
+      expect(TCPClient::Configuration).to receive(:create).once.with(options)
+      TCPClient.configure(options)
     end
 
     it 'returns the new configuratiion' do

data/spec/tcp_client_spec.rb

@@ -130,11 +130,11 @@ RSpec.describe TCPClient do
       expect(client.configuration).to be configuration
     end
 
-    it 'failes when read is called' do
+    it 'fails when read is called' do
       expect { client.read(42) }.to raise_error(TCPClient::NotConnectedError)
     end
 
-    it 'failes when write is called' do
+    it 'fails when write is called' do
       expect { client.write('?!') }.to raise_error(TCPClient::NotConnectedError)
     end
 
@@ -149,12 +149,6 @@ RSpec.describe TCPClient do
     end
   end
 
-  xdescribe '.open' do
-  end
-
-  xdescribe '.with_deadline' do
-  end
-
   context 'when not using SSL' do
     describe '#connect' do
       subject(:client) { TCPClient.new }
@@ -474,7 +468,7 @@ RSpec.describe TCPClient do
                 .once
                 .with(instance_of(Integer), exception: false)
                 .and_return(nil)
-             expect(client.readline(timeout: 10)).to eq "Hello "
+              expect(client.readline(timeout: 10)).to eq 'Hello '
             end
 
             it 'is closed' do
@@ -779,7 +773,7 @@ RSpec.describe TCPClient do
         #     :set_params
         #   )
         #   .once
-        #   .with(ssl_version: :TLSv1_2)
+        #   .with(max_version: :TLS1_3, min_version: :TLS1_2)
         #   .and_call_original
         expect_any_instance_of(::OpenSSL::SSL::SSLSocket).to receive(
             :sync_close=

data/tcp-client.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
 
   spec.author = 'Mike Blumtritt'
   spec.summary = 'A TCP client implementation with working timeout support.'
-  spec.description = <<~description
+  spec.description = <<~DESCRIPTION
     This Gem implements a TCP client with (optional) SSL support.
     It is an easy to use, versatile configurable client that can correctly
     handle time limits.
@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
     predefined/configurable time limits for each method
     (`connect`, `read`, `write`). Deadlines for a sequence of read/write
     actions can also be monitored.
-  description
+  DESCRIPTION
 
   spec.homepage = 'https://github.com/mblumtritt/tcp-client'
   spec.license = 'BSD-3-Clause'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-12 00:00:00.000000000 Z
+date: 2022-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler