net-protocol 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a89e13a67cbddeb513e263e4144b6571764d29575e708fa41bde6b34f22a1861
+  data.tar.gz: 0ebb7c5808ba457116c5824ae27f879adc1dca00141747edeaa573e469d00391
+SHA512:
+  metadata.gz: 561d1dae475c39c9cf2de94c3b9fcc196c134b1f5639b41cd6159d3fd4bba4faf5cd45815cbc9f4b7cf3d57a634032a9a402ff571f6f0ec9c811ca8fa8e67688
+  data.tar.gz: 181700c6865de4b86d2db0c52c7072e40c66dc2bbf5b3ee64747acc5e5c7c46c96d7e625ef068d8089de15a54f346a2c8566c23e1ae842e7ec5d3767f7c7d6f7

data/.github/workflows/test.yml

@@ -0,0 +1,24 @@
+name: ubuntu
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: build (${{ matrix.ruby }} / ${{ matrix.os }})
+    strategy:
+      matrix:
+        ruby: [ 2.7, 2.6, 2.5, 2.4, head ]
+        os: [ ubuntu-latest, macos-latest ]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: |
+        gem install bundler --no-document
+        bundle install
+    - name: Run test
+      run: rake test

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "test-unit"

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    net-protocol (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    power_assert (1.1.5)
+    rake (12.3.3)
+    test-unit (3.3.5)
+      power_assert
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  net-protocol!
+  rake
+  test-unit
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,29 @@
+# Net::Protocol
+
+The abstruct interface for net-* client.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'net-protocol'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install net-protocol
+
+## 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/ruby/net-protocol.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test/lib"
+  t.ruby_opts << "-rhelper"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "net/protocol"
+
+# 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/net/protocol.rb

@@ -0,0 +1,506 @@
+# frozen_string_literal: true
+#
+# = net/protocol.rb
+#
+#--
+# Copyright (c) 1999-2004 Yukihiro Matsumoto
+# Copyright (c) 1999-2004 Minero Aoki
+#
+# written and maintained by Minero Aoki <aamine@loveruby.net>
+#
+# This program is free software. You can re-distribute and/or
+# modify this program under the same terms as Ruby itself,
+# Ruby Distribute License or GNU General Public License.
+#
+# $Id$
+#++
+#
+# WARNING: This file is going to remove.
+# Do not rely on the implementation written in this file.
+#
+
+require 'socket'
+require 'timeout'
+require 'io/wait'
+
+module Net # :nodoc:
+
+  class Protocol   #:nodoc: internal use only
+    private
+    def Protocol.protocol_param(name, val)
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def #{name}
+          #{val}
+        end
+      End
+    end
+
+    def ssl_socket_connect(s, timeout)
+      if timeout
+        while true
+          raise Net::OpenTimeout if timeout <= 0
+          start = Process.clock_gettime Process::CLOCK_MONOTONIC
+          # to_io is required because SSLSocket doesn't have wait_readable yet
+          case s.connect_nonblock(exception: false)
+          when :wait_readable; s.to_io.wait_readable(timeout)
+          when :wait_writable; s.to_io.wait_writable(timeout)
+          else; break
+          end
+          timeout -= Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        end
+      else
+        s.connect
+      end
+    end
+  end
+
+
+  class ProtocolError          < StandardError; end
+  class ProtoSyntaxError       < ProtocolError; end
+  class ProtoFatalError        < ProtocolError; end
+  class ProtoUnknownError      < ProtocolError; end
+  class ProtoServerError       < ProtocolError; end
+  class ProtoAuthError         < ProtocolError; end
+  class ProtoCommandError      < ProtocolError; end
+  class ProtoRetriableError    < ProtocolError; end
+  ProtocRetryError = ProtoRetriableError
+
+  ##
+  # OpenTimeout, a subclass of Timeout::Error, is raised if a connection cannot
+  # be created within the open_timeout.
+
+  class OpenTimeout            < Timeout::Error; end
+
+  ##
+  # ReadTimeout, a subclass of Timeout::Error, is raised if a chunk of the
+  # response cannot be read within the read_timeout.
+
+  class ReadTimeout < Timeout::Error
+    def initialize(io = nil)
+      @io = io
+    end
+    attr_reader :io
+
+    def message
+      msg = super
+      if @io
+        msg = "#{msg} with #{@io.inspect}"
+      end
+      msg
+    end
+  end
+
+  ##
+  # WriteTimeout, a subclass of Timeout::Error, is raised if a chunk of the
+  # response cannot be written within the write_timeout.  Not raised on Windows.
+
+  class WriteTimeout < Timeout::Error
+    def initialize(io = nil)
+      @io = io
+    end
+    attr_reader :io
+
+    def message
+      msg = super
+      if @io
+        msg = "#{msg} with #{@io.inspect}"
+      end
+      msg
+    end
+  end
+
+
+  class BufferedIO   #:nodoc: internal use only
+    def initialize(io, read_timeout: 60, write_timeout: 60, continue_timeout: nil, debug_output: nil)
+      @io = io
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      @continue_timeout = continue_timeout
+      @debug_output = debug_output
+      @rbuf = ''.b
+    end
+
+    attr_reader :io
+    attr_accessor :read_timeout
+    attr_accessor :write_timeout
+    attr_accessor :continue_timeout
+    attr_accessor :debug_output
+
+    def inspect
+      "#<#{self.class} io=#{@io}>"
+    end
+
+    def eof?
+      @io.eof?
+    end
+
+    def closed?
+      @io.closed?
+    end
+
+    def close
+      @io.close
+    end
+
+    #
+    # Read
+    #
+
+    public
+
+    def read(len, dest = ''.b, ignore_eof = false)
+      LOG "reading #{len} bytes..."
+      read_bytes = 0
+      begin
+        while read_bytes + @rbuf.size < len
+          s = rbuf_consume(@rbuf.size)
+          read_bytes += s.size
+          dest << s
+          rbuf_fill
+        end
+        s = rbuf_consume(len - read_bytes)
+        read_bytes += s.size
+        dest << s
+      rescue EOFError
+        raise unless ignore_eof
+      end
+      LOG "read #{read_bytes} bytes"
+      dest
+    end
+
+    def read_all(dest = ''.b)
+      LOG 'reading all...'
+      read_bytes = 0
+      begin
+        while true
+          s = rbuf_consume(@rbuf.size)
+          read_bytes += s.size
+          dest << s
+          rbuf_fill
+        end
+      rescue EOFError
+        ;
+      end
+      LOG "read #{read_bytes} bytes"
+      dest
+    end
+
+    def readuntil(terminator, ignore_eof = false)
+      begin
+        until idx = @rbuf.index(terminator)
+          rbuf_fill
+        end
+        return rbuf_consume(idx + terminator.size)
+      rescue EOFError
+        raise unless ignore_eof
+        return rbuf_consume(@rbuf.size)
+      end
+    end
+
+    def readline
+      readuntil("\n").chop
+    end
+
+    private
+
+    BUFSIZE = 1024 * 16
+
+    def rbuf_fill
+      tmp = @rbuf.empty? ? @rbuf : nil
+      case rv = @io.read_nonblock(BUFSIZE, tmp, exception: false)
+      when String
+        return if rv.equal?(tmp)
+        @rbuf << rv
+        rv.clear
+        return
+      when :wait_readable
+        (io = @io.to_io).wait_readable(@read_timeout) or raise Net::ReadTimeout.new(io)
+        # continue looping
+      when :wait_writable
+        # OpenSSL::Buffering#read_nonblock may fail with IO::WaitWritable.
+        # http://www.openssl.org/support/faq.html#PROG10
+        (io = @io.to_io).wait_writable(@read_timeout) or raise Net::ReadTimeout.new(io)
+        # continue looping
+      when nil
+        raise EOFError, 'end of file reached'
+      end while true
+    end
+
+    def rbuf_consume(len)
+      if len == @rbuf.size
+        s = @rbuf
+        @rbuf = ''.b
+      else
+        s = @rbuf.slice!(0, len)
+      end
+      @debug_output << %Q[-> #{s.dump}\n] if @debug_output
+      s
+    end
+
+    #
+    # Write
+    #
+
+    public
+
+    def write(*strs)
+      writing {
+        write0(*strs)
+      }
+    end
+
+    alias << write
+
+    def writeline(str)
+      writing {
+        write0 str + "\r\n"
+      }
+    end
+
+    private
+
+    def writing
+      @written_bytes = 0
+      @debug_output << '<- ' if @debug_output
+      yield
+      @debug_output << "\n" if @debug_output
+      bytes = @written_bytes
+      @written_bytes = nil
+      bytes
+    end
+
+    def write0(*strs)
+      @debug_output << strs.map(&:dump).join if @debug_output
+      orig_written_bytes = @written_bytes
+      strs.each_with_index do |str, i|
+        need_retry = true
+        case len = @io.write_nonblock(str, exception: false)
+        when Integer
+          @written_bytes += len
+          len -= str.bytesize
+          if len == 0
+            if strs.size == i+1
+              return @written_bytes - orig_written_bytes
+            else
+              need_retry = false
+              # next string
+            end
+          elsif len < 0
+            str = str.byteslice(len, -len)
+          else # len > 0
+            need_retry = false
+            # next string
+          end
+          # continue looping
+        when :wait_writable
+          (io = @io.to_io).wait_writable(@write_timeout) or raise Net::WriteTimeout.new(io)
+          # continue looping
+        end while need_retry
+      end
+    end
+
+    #
+    # Logging
+    #
+
+    private
+
+    def LOG_off
+      @save_debug_out = @debug_output
+      @debug_output = nil
+    end
+
+    def LOG_on
+      @debug_output = @save_debug_out
+    end
+
+    def LOG(msg)
+      return unless @debug_output
+      @debug_output << msg + "\n"
+    end
+  end
+
+
+  class InternetMessageIO < BufferedIO   #:nodoc: internal use only
+    def initialize(*, **)
+      super
+      @wbuf = nil
+    end
+
+    #
+    # Read
+    #
+
+    def each_message_chunk
+      LOG 'reading message...'
+      LOG_off()
+      read_bytes = 0
+      while (line = readuntil("\r\n")) != ".\r\n"
+        read_bytes += line.size
+        yield line.delete_prefix('.')
+      end
+      LOG_on()
+      LOG "read message (#{read_bytes} bytes)"
+    end
+
+    # *library private* (cannot handle 'break')
+    def each_list_item
+      while (str = readuntil("\r\n")) != ".\r\n"
+        yield str.chop
+      end
+    end
+
+    def write_message_0(src)
+      prev = @written_bytes
+      each_crlf_line(src) do |line|
+        write0 dot_stuff(line)
+      end
+      @written_bytes - prev
+    end
+
+    #
+    # Write
+    #
+
+    def write_message(src)
+      LOG "writing message from #{src.class}"
+      LOG_off()
+      len = writing {
+        using_each_crlf_line {
+          write_message_0 src
+        }
+      }
+      LOG_on()
+      LOG "wrote #{len} bytes"
+      len
+    end
+
+    def write_message_by_block(&block)
+      LOG 'writing message from block'
+      LOG_off()
+      len = writing {
+        using_each_crlf_line {
+          begin
+            block.call(WriteAdapter.new(self, :write_message_0))
+          rescue LocalJumpError
+            # allow `break' from writer block
+          end
+        }
+      }
+      LOG_on()
+      LOG "wrote #{len} bytes"
+      len
+    end
+
+    private
+
+    def dot_stuff(s)
+      s.sub(/\A\./, '..')
+    end
+
+    def using_each_crlf_line
+      @wbuf = ''.b
+      yield
+      if not @wbuf.empty?   # unterminated last line
+        write0 dot_stuff(@wbuf.chomp) + "\r\n"
+      elsif @written_bytes == 0   # empty src
+        write0 "\r\n"
+      end
+      write0 ".\r\n"
+      @wbuf = nil
+    end
+
+    def each_crlf_line(src)
+      buffer_filling(@wbuf, src) do
+        while line = @wbuf.slice!(/\A[^\r\n]*(?:\n|\r(?:\n|(?!\z)))/)
+          yield line.chomp("\n") + "\r\n"
+        end
+      end
+    end
+
+    def buffer_filling(buf, src)
+      case src
+      when String    # for speeding up.
+        0.step(src.size - 1, 1024) do |i|
+          buf << src[i, 1024]
+          yield
+        end
+      when File    # for speeding up.
+        while s = src.read(1024)
+          buf << s
+          yield
+        end
+      else    # generic reader
+        src.each do |str|
+          buf << str
+          yield if buf.size > 1024
+        end
+        yield unless buf.empty?
+      end
+    end
+  end
+
+
+  #
+  # The writer adapter class
+  #
+  class WriteAdapter
+    def initialize(socket, method)
+      @socket = socket
+      @method_id = method
+    end
+
+    def inspect
+      "#<#{self.class} socket=#{@socket.inspect}>"
+    end
+
+    def write(str)
+      @socket.__send__(@method_id, str)
+    end
+
+    alias print write
+
+    def <<(str)
+      write str
+      self
+    end
+
+    def puts(str = '')
+      write str.chomp("\n") + "\n"
+    end
+
+    def printf(*args)
+      write sprintf(*args)
+    end
+  end
+
+
+  class ReadAdapter   #:nodoc: internal use only
+    def initialize(block)
+      @block = block
+    end
+
+    def inspect
+      "#<#{self.class}>"
+    end
+
+    def <<(str)
+      call_block(str, &@block) if @block
+    end
+
+    private
+
+    # This method is needed because @block must be called by yield,
+    # not Proc#call.  You can see difference when using `break' in
+    # the block.
+    def call_block(str)
+      yield str
+    end
+  end
+
+
+  module NetPrivate   #:nodoc: obsolete
+    Socket = ::Net::InternetMessageIO
+  end
+
+end   # module Net

data/lib/net/protocol/version.rb

@@ -0,0 +1,5 @@
+module Net
+  class Protocol
+    VERSION = "0.1.0"
+  end
+end

data/net-protocol.gemspec

@@ -0,0 +1,29 @@
+begin
+  require_relative "lib/net/protocol/version"
+rescue LoadError # Fallback to load version file in ruby core repository
+  require_relative "version"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "net-protocol"
+  spec.version       = Net::Protocol::VERSION
+  spec.authors = ["Yukihiro Matsumoto"]
+  spec.email = ["matz@ruby-lang.org"]
+
+  spec.summary       = %q{The abstruct interface for net-* client.}
+  spec.description   = %q{The abstruct interface for net-* client.}
+  spec.homepage      = "https://github.com/ruby/net-protocol"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # 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.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: net-protocol
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yukihiro Matsumoto
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-04-01 00:00:00.000000000 Z
+dependencies: []
+description: The abstruct interface for net-* client.
+email:
+- matz@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/test.yml"
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/net/protocol.rb
+- lib/net/protocol/version.rb
+- net-protocol.gemspec
+homepage: https://github.com/ruby/net-protocol
+licenses: []
+metadata:
+  homepage_uri: https://github.com/ruby/net-protocol
+  source_code_uri: https://github.com/ruby/net-protocol
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.0.pre1
+signing_key: 
+specification_version: 4
+summary: The abstruct interface for net-* client.
+test_files: []