uv-rays 2.3.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2071c1ca1785836a027d0c84859a9ab8f8fdd39
-  data.tar.gz: b82be2f6611fecd989e85693894ea4996ff16cc1
+  metadata.gz: 3e353fd7111af33397aa886f1ac63dd04f98c77a
+  data.tar.gz: 022c6fd79ee1e2c63126f320051b0eec490eca56
 SHA512:
-  metadata.gz: d37fadf118df972c3a8e9ddeddc1142e36e3f45b24e67cfc21e54447b9570156e495d0bdf8181e96660b80e105e8cd075e52042f69c5e4337f8de3fa6bb24ab9
-  data.tar.gz: d962b2226429fb52d9286745881a5c2100680f5601c203780dbfe306016c1bf369ef5d26aa2bb2a4fc26cccb7f8bc7e06adce3f02cb42337602ae13f7a8e9f21
+  metadata.gz: 41d012acf5a07242274956c7807332e185a91a2173f33a5f7c508c0e01076e3d96a4d0517e0d822aeb81037ef2f797c4422afe4f02bebea4b9b47ccea0882fa2
+  data.tar.gz: 1b9f591075b747c840a7d47d75903459e49afef2c44f99cafad7c3a022552ffb49a1458e8756e71dd9f28301d4302050ceae65e95242b1fa8f0aa7244b186b77

data/lib/uv-rays.rb

@@ -1,94 +1,93 @@
-# frozen_string_literal: true
-
-require 'libuv'
-
-
-# In-memory event scheduling
-require 'set'               # ruby std lib
-require 'bisect'            # insert into a sorted array
-require 'tzinfo'            # timezone information
-require 'uv-rays/scheduler/time'
-require 'uv-rays/scheduler'
-
-# Intelligent stream buffering
-require 'uv-rays/buffered_tokenizer'
-require 'uv-rays/abstract_tokenizer'
-
-# TCP Connections
-require 'ipaddress'         # IP Address parser
-require 'uv-rays/tcp_server'
-require 'uv-rays/connection'
-
-# HTTP related methods
-require 'cookiejar'         # Manages cookies
-require 'http-parser'       # Parses HTTP request / responses
-require 'addressable/uri'   # URI parser
-require 'uv-rays/http/encoding'
-require 'uv-rays/http/request'
-require 'uv-rays/http/parser'
-require 'uv-rays/http_endpoint'
-
-
-
-module UV
-
-    # @private
-    def self.klass_from_handler(klass, handler = nil, *args)
-        klass = if handler and handler.is_a?(Class)
-            raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
-            handler
-        elsif handler
-            begin
-                handler::UR_CONNECTION_CLASS
-            rescue NameError
-                handler::const_set(:UR_CONNECTION_CLASS, Class.new(klass) {include handler})
-            end
-        else
-            klass
-        end
-
-        arity = klass.instance_method(:post_init).arity
-        expected = arity >= 0 ? arity : -(arity + 1)
-        if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
-            raise ArgumentError, "wrong number of arguments for #{klass}#post_init (#{args.size} for #{expected})"
-        end
-
-        klass
-    end
-
-
-    def self.connect(server, port, handler, *args)
-        klass = klass_from_handler(OutboundConnection, handler, *args)
-
-        c = klass.new server, port
-        c.post_init *args
-        c
-    end
-
-    def self.start_server(server, port, handler, *args)
-        thread = reactor   # Get the reactor running on this thread
-        raise ThreadError, "There is no Libuv reactor running on the current thread" if thread.nil?
-
-        klass = klass_from_handler(InboundConnection, handler, *args)
-        UV::TcpServer.new thread, server, port, klass, *args
-    end
-
-    def self.attach_server(sock, handler, *args)
-        thread = reactor   # Get the reactor running on this thread
-        raise ThreadError, "There is no Libuv reactor running on the current thread" if thread.nil?
-
-        klass = klass_from_handler(InboundConnection, handler, *args)
-        sd = sock.respond_to?(:fileno) ? sock.fileno : sock
-
-        UV::TcpServer.new thread, sd, sd, klass, *args
-    end
-
-    def self.open_datagram_socket(handler, server = nil, port = nil, *args)
-        klass = klass_from_handler(DatagramConnection, handler, *args)
-
-        c = klass.new server, port
-        c.post_init *args
-        c
-    end
-end
-
+# frozen_string_literal: true
+
+require 'libuv'
+
+
+# In-memory event scheduling
+require 'set'               # ruby std lib
+require 'bisect'            # insert into a sorted array
+require 'tzinfo'            # timezone information
+require 'uv-rays/scheduler/time'
+require 'uv-rays/scheduler'
+
+# Intelligent stream buffering
+require 'uv-rays/buffered_tokenizer'
+require 'uv-rays/abstract_tokenizer'
+
+# TCP Connections
+require 'ipaddress'         # IP Address parser
+require 'uv-rays/tcp_server'
+require 'uv-rays/connection'
+
+# HTTP related methods
+require 'cookiejar'         # Manages cookies
+require 'http-parser'       # Parses HTTP request / responses
+require 'addressable/uri'   # URI parser
+require 'uv-rays/http/encoding'
+require 'uv-rays/http/request'
+require 'uv-rays/http/parser'
+require 'uv-rays/http_endpoint'
+
+
+
+module UV
+
+    # @private
+    def self.klass_from_handler(klass, handler = nil, *args)
+        klass = if handler and handler.is_a?(Class)
+            raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
+            handler
+        elsif handler
+            begin
+                handler::UR_CONNECTION_CLASS
+            rescue NameError
+                handler::const_set(:UR_CONNECTION_CLASS, Class.new(klass) {include handler})
+            end
+        else
+            klass
+        end
+
+        arity = klass.instance_method(:post_init).arity
+        expected = arity >= 0 ? arity : -(arity + 1)
+        if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+            raise ArgumentError, "wrong number of arguments for #{klass}#post_init (#{args.size} for #{expected})"
+        end
+
+        klass
+    end
+
+
+    def self.connect(server, port, handler, *args)
+        klass = klass_from_handler(OutboundConnection, handler, *args)
+
+        c = klass.new server, port
+        c.post_init *args
+        c
+    end
+
+    def self.start_server(server, port, handler, *args)
+        thread = reactor   # Get the reactor running on this thread
+        raise ThreadError, "There is no Libuv reactor running on the current thread" if thread.nil?
+
+        klass = klass_from_handler(InboundConnection, handler, *args)
+        UV::TcpServer.new thread, server, port, klass, *args
+    end
+
+    def self.attach_server(sock, handler, *args)
+        thread = reactor   # Get the reactor running on this thread
+        raise ThreadError, "There is no Libuv reactor running on the current thread" if thread.nil?
+
+        klass = klass_from_handler(InboundConnection, handler, *args)
+        sd = sock.respond_to?(:fileno) ? sock.fileno : sock
+
+        UV::TcpServer.new thread, sd, sd, klass, *args
+    end
+
+    def self.open_datagram_socket(handler, server = nil, port = nil, *args)
+        klass = klass_from_handler(DatagramConnection, handler, *args)
+
+        c = klass.new server, port
+        c.post_init *args
+        c
+    end
+end

data/lib/uv-rays/abstract_tokenizer.rb

@@ -112,4 +112,4 @@ module UV
             @input = String.new.force_encoding(@encoding)
         end
     end
-end
+end

data/lib/uv-rays/buffered_tokenizer.rb

@@ -167,4 +167,4 @@ module UV
             String.new.force_encoding(@encoding)
         end
     end
-end
+end

data/lib/uv-rays/connection.rb

@@ -1,188 +1,188 @@
-# frozen_string_literal: true
-
-module UV
-    def self.try_connect(tcp, handler, server, port)
-        if IPAddress.valid? server
-            tcp.finally handler.method(:on_close)
-            tcp.progress handler.method(:on_read)
-            tcp.connect server, port do
-                tcp.enable_nodelay
-                tcp.start_tls(handler.using_tls) if handler.using_tls
-
-                # on_connect could call use_tls so must come after start_tls
-                handler.on_connect(tcp)
-                tcp.start_read
-            end
-        else
-            tcp.reactor.lookup(server, wait: false).then(
-                proc { |result|
-                    UV.try_connect(tcp, handler, result[0][0], port)
-                },
-                proc { |failure|
-                    # TODO:: Log error on reactor
-                    handler.on_close
-                }
-            )
-        end
-    end
-
-
-    # @abstract
-    class Connection
-        attr_reader :using_tls
-
-        def initialize
-            @send_queue = []
-            @paused = false
-            @using_tls = false
-        end
-
-        def pause
-            @paused = true
-            @transport.stop_read
-        end
-
-        def paused?
-            @paused
-        end
-
-        def resume
-            @paused = false
-            @transport.start_read
-        end
-
-        # Compatible with TCP
-        def close_connection(*args)
-            @transport.close
-        end
-
-        def on_read(data, *args) # user to define
-        end
-
-        def post_init(*args)
-        end
-    end
-
-    class TcpConnection < Connection
-        def write(data)
-            @transport.write(data, wait: :promise)
-        end
-
-        def close_connection(after_writing = false)
-            if after_writing
-                @transport.shutdown
-            else
-                @transport.close
-            end
-        end
-
-        def stream_file(filename, type = :raw)
-            file = @reactor.file(filename, File::RDONLY) do    # File is open and available for reading
-                file.send_file(@transport, type, wait: :promise).finally do
-                    file.close
-                end
-            end
-            return file
-        end
-
-        def keepalive(raw_time)
-            time = raw_time.to_i
-            if time.to_i <= 0
-                @transport.disable_keepalive
-            else
-                @transport.enable_keepalive(time)
-            end
-        end
-
-        def on_connect(transport) # user to define
-        end
-
-        def on_close # user to define
-        end
-    end
-
-    class InboundConnection < TcpConnection
-        def initialize(tcp)
-            super()
-
-            @reactor = tcp.reactor
-            @transport = tcp
-            @transport.finally method(:on_close)
-            @transport.progress method(:on_read)
-        end
-
-        def use_tls(args = {})
-            args[:server] = true
-
-            if @transport.connected
-                @transport.start_tls(args)
-            else
-                @using_tls = args
-            end
-        end
-    end
-
-    class OutboundConnection < TcpConnection
-
-        def initialize(server, port)
-            super()
-
-            @reactor = reactor
-            @server = server
-            @port = port
-            @transport = @reactor.tcp
-
-            ::UV.try_connect(@transport, self, @server, @port)
-        end
-
-        def use_tls(args = {})
-            args.delete(:server)
-
-            if @transport.connected
-                @transport.start_tls(args)
-            else
-                @using_tls = args
-            end
-        end
-
-        def reconnect(server = nil, port = nil)
-            @reactor = reactor
-
-            @transport = @reactor.tcp
-            @server = server || @server
-            @port = port || @port
-
-            ::UV.try_connect(@transport, self, @server, @port)
-        end
-    end
-
-    class DatagramConnection < Connection
-        def initialize(server = nil, port = nil)
-            super()
-
-            @reactor = reactor
-            @transport = @reactor.udp
-            @transport.progress method(:on_read)
-
-            if not server.nil?
-                server = '127.0.0.1' if server == 'localhost'
-                raise ArgumentError, "Invalid server address #{server}" unless IPAddress.valid?(server)
-                @transport.bind(server, port)
-            end
-
-            @transport.start_read
-        end
-
-        def send_datagram(data, recipient_address, recipient_port)
-            if IPAddress.valid? recipient_address
-                @transport.send recipient_address, recipient_port, data
-            else
-                # Async DNS resolution
-                # Note:: send here will chain the promise
-                @reactor.lookup(recipient_address).then do |result|
-                    @transport.send result[0][0], recipient_port, data
-                end
-            end
-        end
-    end
-end
+# frozen_string_literal: true
+
+module UV
+    def self.try_connect(tcp, handler, server, port)
+        if IPAddress.valid? server
+            tcp.finally handler.method(:on_close)
+            tcp.progress handler.method(:on_read)
+            tcp.connect server, port do
+                tcp.enable_nodelay
+                tcp.start_tls(handler.using_tls) if handler.using_tls
+
+                # on_connect could call use_tls so must come after start_tls
+                handler.on_connect(tcp)
+                tcp.start_read
+            end
+        else
+            tcp.reactor.lookup(server, wait: false).then(
+                proc { |result|
+                    UV.try_connect(tcp, handler, result[0][0], port)
+                },
+                proc { |failure|
+                    # TODO:: Log error on reactor
+                    handler.on_close
+                }
+            )
+        end
+    end
+
+
+    # @abstract
+    class Connection
+        attr_reader :using_tls
+
+        def initialize
+            @send_queue = []
+            @paused = false
+            @using_tls = false
+        end
+
+        def pause
+            @paused = true
+            @transport.stop_read
+        end
+
+        def paused?
+            @paused
+        end
+
+        def resume
+            @paused = false
+            @transport.start_read
+        end
+
+        # Compatible with TCP
+        def close_connection(*args)
+            @transport.close
+        end
+
+        def on_read(data, *args) # user to define
+        end
+
+        def post_init(*args)
+        end
+    end
+
+    class TcpConnection < Connection
+        def write(data)
+            @transport.write(data, wait: :promise)
+        end
+
+        def close_connection(after_writing = false)
+            if after_writing
+                @transport.shutdown
+            else
+                @transport.close
+            end
+        end
+
+        def stream_file(filename, type = :raw)
+            file = @reactor.file(filename, File::RDONLY) do    # File is open and available for reading
+                file.send_file(@transport, type, wait: :promise).finally do
+                    file.close
+                end
+            end
+            return file
+        end
+
+        def keepalive(raw_time)
+            time = raw_time.to_i
+            if time.to_i <= 0
+                @transport.disable_keepalive
+            else
+                @transport.enable_keepalive(time)
+            end
+        end
+
+        def on_connect(transport) # user to define
+        end
+
+        def on_close # user to define
+        end
+    end
+
+    class InboundConnection < TcpConnection
+        def initialize(tcp)
+            super()
+
+            @reactor = tcp.reactor
+            @transport = tcp
+            @transport.finally method(:on_close)
+            @transport.progress method(:on_read)
+        end
+
+        def use_tls(args = {})
+            args[:server] = true
+
+            if @transport.connected
+                @transport.start_tls(args)
+            else
+                @using_tls = args
+            end
+        end
+    end
+
+    class OutboundConnection < TcpConnection
+
+        def initialize(server, port)
+            super()
+
+            @reactor = reactor
+            @server = server
+            @port = port
+            @transport = @reactor.tcp
+
+            ::UV.try_connect(@transport, self, @server, @port)
+        end
+
+        def use_tls(args = {})
+            args.delete(:server)
+
+            if @transport.connected
+                @transport.start_tls(args)
+            else
+                @using_tls = args
+            end
+        end
+
+        def reconnect(server = nil, port = nil)
+            @reactor = reactor
+
+            @transport = @reactor.tcp
+            @server = server || @server
+            @port = port || @port
+
+            ::UV.try_connect(@transport, self, @server, @port)
+        end
+    end
+
+    class DatagramConnection < Connection
+        def initialize(server = nil, port = nil)
+            super()
+
+            @reactor = reactor
+            @transport = @reactor.udp
+            @transport.progress method(:on_read)
+
+            if not server.nil?
+                server = '127.0.0.1' if server == 'localhost'
+                raise ArgumentError, "Invalid server address #{server}" unless IPAddress.valid?(server)
+                @transport.bind(server, port)
+            end
+
+            @transport.start_read
+        end
+
+        def send_datagram(data, recipient_address, recipient_port)
+            if IPAddress.valid? recipient_address
+                @transport.send recipient_address, recipient_port, data
+            else
+                # Async DNS resolution
+                # Note:: send here will chain the promise
+                @reactor.lookup(recipient_address).then do |result|
+                    @transport.send result[0][0], recipient_port, data
+                end
+            end
+        end
+    end
+end