backport 0.3.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9693d9fb93dc1efb03c85d3abe258cd54e2fa4bca03e8bc2f64a45a56783269a
-  data.tar.gz: a7abdaa602ccbfda748cdace2af071af73651ecff42663ac237def501260f457
+  metadata.gz: bb7787742f0eda4aab85f3b7cd388f69ad1870a4298f4b6f4862577f198685f0
+  data.tar.gz: 00c7263e5c3dc511f3a13a12d2e5cf7335d9c2feab66b63430ae363975284b73
 SHA512:
-  metadata.gz: bbc92f9838a571f7cb9ea71334961cf34013a41e1010147ec4f54d4c5efde68c37b4f7cb9f0d9d52ad8ebe23ac9fa83e24568d690044ed200d838a1cb2c50358
-  data.tar.gz: a5cdf05eb09d40bc352fd07ed2d23b85107875551c9718e0145e7abdf92f670ff784e99b50b8daf5879c7a0cbe92dca1d8ca4b3a42ed73a482610085fd56e986
+  metadata.gz: cc68f707447563a776948af2e86cfd2d683659fe11ce81ee21d37536e7fc5818935ff9e763a4fcb4d4022460cf3088c14f830fa1faefb9577aff959a5a6e0c3a
+  data.tar.gz: 14be66a01490aaa143da303aac0f9f0c3061ea4dbad0e284f4e07a463fc5dd6b807b677b3f70f1ce8191312b3b12d1429bb8e87d883bf3ea61e9bc8fcd91eee9

data/.rubocop.yml

@@ -2,3 +2,5 @@ Style/MethodDefParentheses:
   Enabled: false
 Layout/EmptyLineAfterGuardClause:
   Enabled: false
+Style/StringLiterals:
+  Enabled: false

data/.travis.yml

@@ -1,18 +1,21 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - 2.5.1
-  - 2.5.3
-  - jruby-9.0.5.0
-  - jruby-9.1.16.0
-matrix:
-  include:
-    - rvm: 2.4
-      os: osx
-before_install: gem install bundler -v 1.17.2
+---
+sudo: false
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - jruby-head
+matrix:
+  include:
+    - rvm: 2.6
+      os: osx
+  allow_failures:
+    - rvm: jruby-head
+
+before_install: gem install bundler -v 1.17.2
+script: rspec --format documentation

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 1.2.0 - June 13, 2021
+- Improved handling of multiple machines
+- Rescue StandardError instead of Exception
+
+## 1.1.2 - August 4, 2019
+- Rescue Errno::ENOTSOCK
+
+## 1.1.1 - May 28, 2019
+- Interval server synchronizes updates and ready state
+- Spec and CI changes
+
+## 1.1.0 - May 27, 2019
+- Interval server uses threads for timing
+- Servers use observer patterns to reduce polling
+
+## 1.0.0 - February 19, 2019
+- Renamed Adapter#sending to Adapter#receiving
+- Travis tests up to Ruby 2.6
+
 ## 0.3.0 - January 10, 2019
 - Basic logging
 - Differentiate between "expected" and "unexpected" exceptions in Tcpip

data/Gemfile

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

data/README.md

@@ -1,80 +1,80 @@
-# Backport
-
-A pure Ruby library for event-driven IO.
-
-This library is designed with portability as the highest priority, which is why it's written in pure Ruby. Consider [EventMachine](https://github.com/eventmachine/eventmachine) if you need a solution that's faster, more mature, and scalable.
-
-## Installation
-
-Install the gem:
-
-```
-gem install backport
-```
-
-Or add it to your application's Gemfile:
-
-```ruby
-gem 'backport'
-```
-
-## Usage
-
-### Examples
-
-A simple echo server:
-
-```ruby
-require 'backport'
-
-module MyAdapter
-  def opening
-    puts "Opening a connection"
-  end
-
-  def closing
-    puts "Closing a connection"
-  end
-
-  def sending data
-    write "Client sent: #{data}"
-  end
-end
-
-Backport.run do
-  Backport.prepare_tcp_server(host: 'localhost', port: 8000, adapter: MyAdapter)
-end
-```
-
-An interval server that runs once per second:
-
-```ruby
-require 'backport'
-
-Backport.run do
-  Backport.prepare_interval 1 do
-    puts "tick"
-  end
-end
-```
-
-### Using Adapters
-
-Backport servers that handle client connections, such as TCP servers, use an
-adapter to provide an application interface to the client. Developers can
-provide their own adapter implementations in two ways: a Ruby module that will
-be used to extend a Backport::Adapter object, or a class that extends
-Backport::Adapter. In either case, the adapter should provide the following
-methods:
-
-* `opening`: A callback triggered when the client connection is accepted
-* `closing`: A callback triggered when the client connection is closed
-* `sending(data)`: A callback triggered when the server receives data from the client
-
-Backport::Adapter also provides the following methods:
-
-* `write(data)`: Send raw data to the client
-* `write_line(data)`: Send a line of data to the client
-* `close`: Disconnect the client from the server
-* `closed?`: True if the connection is closed
-* `remote`: A hash of data about the client, e.g., the remote IP address
+# Backport
+
+A pure Ruby library for event-driven IO.
+
+This library is designed with portability as the highest priority, which is why it's written in pure Ruby. Consider [EventMachine](https://github.com/eventmachine/eventmachine) if you need a solution that's faster, more mature, and scalable.
+
+## Installation
+
+Install the gem:
+
+```
+gem install backport
+```
+
+Or add it to your application's Gemfile:
+
+```ruby
+gem 'backport'
+```
+
+## Usage
+
+### Examples
+
+A simple echo server:
+
+```ruby
+require 'backport'
+
+module MyAdapter
+  def opening
+    puts "Opening a connection"
+  end
+
+  def closing
+    puts "Closing a connection"
+  end
+
+  def receiving data
+    write "Client sent: #{data}"
+  end
+end
+
+Backport.run do
+  Backport.prepare_tcp_server(host: 'localhost', port: 8000, adapter: MyAdapter)
+end
+```
+
+An interval server that runs once per second:
+
+```ruby
+require 'backport'
+
+Backport.run do
+  Backport.prepare_interval 1 do
+    puts "tick"
+  end
+end
+```
+
+### Using Adapters
+
+Backport servers that handle client connections, such as TCP servers, use an
+adapter to provide an application interface to the client. Developers can
+provide their own adapter implementations in two ways: a Ruby module that will
+be used to extend a Backport::Adapter object, or a class that extends
+Backport::Adapter. In either case, the adapter should provide the following
+methods:
+
+* `opening`: A callback triggered when the client connection is accepted
+* `closing`: A callback triggered when the client connection is closed
+* `receiving(data)`: A callback triggered when the server receives data from the client
+
+Backport::Adapter also provides the following methods:
+
+* `write(data)`: Send raw data to the client
+* `write_line(data)`: Send a line of data to the client
+* `close`: Disconnect the client from the server
+* `closed?`: True if the connection is closed
+* `remote`: A hash of data about the client, e.g., the remote IP address

data/backport.gemspec

@@ -1,27 +1,28 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "backport/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "backport"
-  spec.version       = Backport::VERSION
-  spec.authors       = ["Fred Snyder"]
-  spec.email         = ["fsnyder@castwide.com"]
-
-  spec.summary       = %q{A pure Ruby library for event-driven IO}
-  spec.homepage      = "http://github.com/castwide/backport"
-  spec.license       = "MIT"
-
-  # 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.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.17"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "simplecov", "~> 0.14"
-end
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "backport/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "backport"
+  spec.version       = Backport::VERSION
+  spec.authors       = ["Fred Snyder"]
+  spec.email         = ["fsnyder@castwide.com"]
+
+  spec.summary       = %q{A pure Ruby library for event-driven IO}
+  spec.homepage      = "http://github.com/castwide/backport"
+  spec.license       = "MIT"
+
+  # 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.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.1'
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov", "~> 0.14"
+end

data/lib/backport.rb

@@ -1,4 +1,4 @@
-require "backport/version"
+require 'backport/version'
 require 'logger'
 
 # An event-driven IO library.
@@ -15,7 +15,7 @@ module Backport
     # @param adapter [Adapter]
     # @return [void]
     def prepare_stdio_server adapter: Adapter
-      machine.prepare Backport::Server::Stdio.new(adapter: adapter)
+      machines.last.prepare Backport::Server::Stdio.new(adapter: adapter)
     end
 
     # Prepare a TCP server to run in Backport.
@@ -25,7 +25,7 @@ module Backport
     # @param adapter [Adapter]
     # @return [void]
     def prepare_tcp_server host: 'localhost', port: 1117, adapter: Adapter
-      machine.prepare Backport::Server::Tcpip.new(host: host, port: port, adapter: adapter)
+      machines.last.prepare Backport::Server::Tcpip.new(host: host, port: port, adapter: adapter)
     end
 
     # Prepare an interval server to run in Backport.
@@ -33,7 +33,7 @@ module Backport
     # @param period [Float] Seconds between intervals
     # @return [void]
     def prepare_interval period, &block
-      machine.prepare Backport::Server::Interval.new(period, &block)
+      machines.last.prepare Backport::Server::Interval.new(period, &block)
     end
 
     # Run the Backport machine. The provided block will be executed before the
@@ -48,25 +48,39 @@ module Backport
     #
     # @return [void]
     def run &block
+      machine = Machine.new
+      machines.push machine
       machine.run &block
+      machines.delete machine
     end
 
-    # Stop the Backport machine.
+    # Stop all running Backport machines.
+    #
+    # For more accurate control, consider stopping the machine
+    # from the self reference in Machine#run, e.g.:
+    #
+    # ```
+    # Backport.run do |machine|
+    #   # ...
+    #   machine.stop
+    # end
+    # ```
     #
     # @return [void]
     def stop
-      machine.stop
+      machines.last.stop unless machines.empty?
     end
 
+    # @return [Logger]
     def logger
       @logger ||= Logger.new(STDERR, level: Logger::WARN, progname: 'Backport')
     end
 
     private
 
-    # @return [Machine]
-    def machine
-      @machine ||= Machine.new
+    # @return [Array<Machine>]
+    def machines
+      @machines ||= []
     end
   end
 end

data/lib/backport/adapter.rb

@@ -40,13 +40,13 @@ module Backport
     # @return [void]
     def closing; end
 
-    # A callback triggered when the client sends data to the server. Subclasses
-    # and/or modules should override this method to provide their own
-    # functionality.
+    # A callback triggered when the server receives data from the client.
+    # Subclasses and/or modules should override this method to provide their
+    # own functionality.
     #
     # @param data [String]
     # @return [void]
-    def sending(data); end
+    def receiving(data); end
 
     # Send data to the client.
     #
@@ -76,9 +76,11 @@ module Backport
     #   The server is responsible for implementation details like closing the
     #   client's socket.
     #
+    # @return [void]
     def close
       return if closed?
       _data[:closed] = true
+      _data[:on_close].call unless _data[:on_close].nil?
       closing
     end
   end

data/lib/backport/client.rb

@@ -1,18 +1,29 @@
+require 'observer'
+
 module Backport
   # A client connected to a connectable Backport server.
   #
   class Client
+    include Observable
+
     # @return [Adapter]
     attr_reader :adapter
 
+    # @param input [IO]
+    # @param output [IO]
+    # @param adapter [Class, Module]
+    # @param remote [Hash]
     def initialize input, output, adapter, remote = {}
       @in = input
       @out = output
+      @mutex = Mutex.new
       @adapter = make_adapter(adapter, remote)
       @stopped = true
       @buffer = ''
     end
 
+    # True if the client is stopped.
+    #
     def stopped?
       @stopped ||= false
     end
@@ -23,15 +34,19 @@ module Backport
     # callback. The server is responsible for implementation details like
     # closing the client's socket.
     #
+    # @return [void]
     def stop
       return if stopped?
       @adapter.closing
       @stopped = true
+      changed
+      notify_observers self
     end
 
     # Start running the client. This method will start the thread that reads
     # client input from IO.
     #
+    # @return [void]
     def start
       return unless stopped?
       @stopped = false
@@ -41,13 +56,18 @@ module Backport
     # @deprecated Prefer #start to #run for non-blocking client/server methods
     alias run start
 
-    # Notify the adapter that the client is sending data.
+    # Handle a tick from the server. This method will check for client input
+    # and update the adapter accordingly, or stop the client if the adapter is
+    # closed.
     #
-    # @param data [String]
-    def sending data
-      @adapter.sending data
+    # @return [void]
+    def tick
+      input = read
+      @adapter.receiving input unless input.nil?
     end
 
+    private
+
     # Read the client input. Return nil if the input buffer is empty.
     #
     # @return [String, nil]
@@ -60,38 +80,48 @@ module Backport
       return tmp unless tmp.empty?
     end
 
-    private
-
-    def make_adapter cls_mod, remote
-      if cls_mod.is_a?(Class) && cls_mod <= Backport::Adapter
-        @adapter = cls_mod.new(@out, remote)
-      elsif cls_mod.class == Module
+    # @param mod_cls [Module, Class] The Adapter module or class
+    # @param remote [Hash] Remote client data
+    # @return [Adapter]
+    def make_adapter mod_cls, remote
+      if mod_cls.is_a?(Class) && mod_cls <= Backport::Adapter
+        @adapter = mod_cls.new(@out, remote)
+      elsif mod_cls.class == Module
         @adapter = Adapter.new(@out, remote)
-        @adapter.extend cls_mod
+        @adapter.extend mod_cls
       else
-        raise TypeError, "#{cls_mod} is not a valid Backport adapter"
+        raise TypeError, "#{mod_cls} is not a valid Backport adapter"
       end
     end
 
-    def mutex
-      @mutex ||= Mutex.new
-    end
+    # @return [Mutex]
+    attr_reader :mutex
 
+    # Start the thread that checks the input IO for client data.
+    #
+    # @return [void]
     def run_input_thread
       Thread.new do
-        until stopped?
-          @in.flush
-          begin
-            chars = @in.sysread(255)
-          rescue EOFError, Errno::ECONNRESET
-            chars = nil
-          end
-          if chars.nil?
-            stop
-            break
-          end
-          mutex.synchronize { @buffer.concat chars }
-        end
+        read_input until stopped?
+      end
+    end
+
+    # Read input from the client.
+    #
+    # @return [void]
+    def read_input
+      begin
+        @in.flush
+        chars = @in.sysread(255)
+      rescue EOFError, IOError, Errno::ECONNRESET, Errno::ENOTSOCK
+        chars = nil
+      end
+      if chars.nil?
+        stop
+      else
+        mutex.synchronize { @buffer.concat chars }
+        changed
+        notify_observers self
       end
     end
   end

data/lib/backport/machine.rb

@@ -4,18 +4,20 @@ module Backport
   class Machine
     def initialize
       @stopped = true
+      @mutex = Mutex.new
     end
 
     # Run the machine. If a block is provided, it gets executed before the
     # maching starts its main loop. The main loop blocks program execution
     # until the machine is stopped.
     #
+    # @yieldparam [self]
     # @return [void]
     def run
       return unless stopped?
       servers.clear
       @stopped = false
-      yield if block_given?
+      yield self if block_given?
       run_server_thread
     end
 
@@ -41,6 +43,7 @@ module Backport
     # @param server [Server::Base]
     # @return [void]
     def prepare server
+      server.add_observer self
       servers.push server
       server.start unless stopped?
     end
@@ -50,20 +53,28 @@ module Backport
       @servers ||= []
     end
 
-    def tick
-      servers.delete_if(&:stopped?)
-      stop if servers.empty?
-      servers.each(&:tick)
+    # @param server [Server::Base]
+    # @return [void]
+    def update server
+      if server.stopped?
+        servers.delete server
+        stop if servers.empty?
+      else
+        mutex.synchronize { server.tick }
+      end
     end
 
     private
 
+    # @return [Mutex]
+    attr_reader :mutex
+
+    # Start the thread that updates servers via the #tick method.
+    #
+    # @return [void]
     def run_server_thread
       servers.map(&:start)
-      until stopped?
-        tick
-        sleep 0.001
-      end
+      sleep 0.1 until stopped?
     end
   end
 end

data/lib/backport/server/base.rb

@@ -1,11 +1,16 @@
+require 'observer'
+
 module Backport
   module Server
     # An extendable server class that provides basic start/stop functionality
     # and common callbacks.
     #
     class Base
+      include Observable
+
       # Start the server.
       #
+      # @return [void]
       def start
         return if started?
         starting
@@ -14,10 +19,13 @@ module Backport
 
       # Stop the server.
       #
+      # @return [void]
       def stop
         return if stopped?
         stopping
         @started = false
+        changed
+        notify_observers self
       end
 
       def started?

data/lib/backport/server/connectable.rb

@@ -5,17 +5,12 @@ module Backport
     # Connectable servers check clients for incoming data on each tick.
     #
     module Connectable
-      def tick
-        clients.each do |client|
-          input = client.read
-          client.sending input unless input.nil?
-        end
-      end
-
+      # @return [void]
       def starting
         clients.map(&:run)
       end
 
+      # @return [void]
       def stopping
         clients.map(&:stop)
       end
@@ -24,6 +19,13 @@ module Backport
       def clients
         @clients ||= []
       end
+
+      private
+
+      # @return [Mutex]
+      def mutex
+        @mutex ||= Mutex.new
+      end
     end
   end
 end

data/lib/backport/server/interval.rb

@@ -9,18 +9,36 @@ module Backport
       def initialize period, &block
         @period = period
         @block = block
-        @last_time = Time.now
+        @ready = false
+        @mutex = Mutex.new
       end
 
       def starting
-        @last_time = Time.now
+        @ready = false
+        run_ready_thread
       end
 
       def tick
-        now = Time.now
-        return unless now - @last_time >= @period
-        @block.call self
-        @last_time = now
+        return unless @ready
+        @mutex.synchronize do
+          @block.call self
+          @ready = false
+        end
+      end
+
+      private
+
+      # @return [void]
+      def run_ready_thread
+        Thread.new do
+          until stopped?
+            sleep @period
+            break if stopped?
+            @mutex.synchronize { @ready = true }
+            changed
+            notify_observers self
+          end
+        end
       end
     end
   end

data/lib/backport/server/stdio.rb

@@ -5,12 +5,22 @@ module Backport
     class Stdio < Base
       include Connectable
 
+      # @param input [IO]
+      # @param output [IO]
+      # @param adapter [Module, Class]
       def initialize input: STDIN, output: STDOUT, adapter: Adapter
         @in = input
         @out = output
         @out.binmode
         @adapter = adapter
         clients.push Client.new(input, output, adapter)
+        clients.last.add_observer self
+      end
+
+      # @param client [Client]
+      # @return [void]
+      def update client
+        client.tick
       end
     end
   end

data/lib/backport/server/tcpip.rb

@@ -8,26 +8,16 @@ module Backport
     class Tcpip < Base
       include Connectable
 
+      # @param host [String]
+      # @param port [Integer]
+      # @param adapter [Module, Class]
+      # @param socket_class [Class]
       def initialize host: 'localhost', port: 1117, adapter: Adapter, socket_class: TCPServer
         @socket = socket_class.new(host, port)
         @adapter = adapter
         @stopped = false
       end
 
-      def tick
-        mutex.synchronize do
-          clients.each do |client|
-            if client.adapter.closed?
-              client.stop
-              next
-            end
-            input = client.read
-            client.sending input unless input.nil?
-          end
-          clients.delete_if(&:stopped?)
-        end
-      end
-
       def starting
         start_accept_thread
       end
@@ -37,8 +27,8 @@ module Backport
         return if socket.closed?
         begin
           socket.shutdown Socket::SHUT_RDWR
-        rescue Errno::ENOTCONN, IOError => e
-          Backport.logger.info "Minor exception while stopping server [#{e.class}] #{e.message}"
+        rescue Errno::ENOTCONN, IOError => err
+          Backport.logger.info "Minor exception while stopping server [#{err.class}] #{err.message}"
         end
         socket.close
       end
@@ -52,7 +42,7 @@ module Backport
         result = nil
         mutex.synchronize do
           begin
-            conn = socket.accept_nonblock
+            conn = socket.accept
             addr = conn.addr(true)
             data = {
               family: addr[0],
@@ -61,14 +51,21 @@ module Backport
               address: addr[3]
             }
             clients.push Client.new(conn, conn, @adapter, data)
+            this = self
+            clients.last.adapter._data[:on_close] = Proc.new {
+              conn.close
+              changed
+              notify_observers this
+            }
+            clients.last.add_observer self
             clients.last.run
             result = clients.last
-          rescue IO::WaitReadable, Errno::EAGAIN => e
+          rescue IO::WaitReadable, Errno::EAGAIN
             # ignore
           rescue Errno::ENOTSOCK, IOError => e
             Backport.logger.info "Server stopped with minor exception [#{e.class}] #{e.message}"
             stop
-          rescue Exception => e
+          rescue StandardError => e
             Backport.logger.warn "Server stopped with major exception [#{e.class}] #{e.message}"
             stop
           end
@@ -76,15 +73,22 @@ module Backport
         result
       end
 
+      # @param client [Client]
+      # @return [void]
+      def update client
+        if client.stopped?
+          clients.delete client
+        else
+          client.tick
+        end
+      end
+
       private
 
       # @return [TCPSocket]
       attr_reader :socket
 
-      def mutex
-        @mutex ||= Mutex.new
-      end
-
+      # @return [void]
       def start_accept_thread
         Thread.new do
           until stopped?

data/lib/backport/version.rb

@@ -1,3 +1,3 @@
 module Backport
-  VERSION = '0.3.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: backport
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Fred Snyder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-10 00:00:00.000000000 Z
+date: 2021-06-13 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.17'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -108,15 +94,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A pure Ruby library for event-driven IO