lightio 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c471b6d1a0f049a6db03568e4f2ab5c0ac718f7c
-  data.tar.gz: 6cf6282f1f363bb1f01eea73fa7443e485b64e0e
+  metadata.gz: 743e461666313c581ce9bea53674e037a237d3a9
+  data.tar.gz: 381120d60e506278cb77c80ad8d2384fed8f51a0
 SHA512:
-  metadata.gz: 430b7f1839c6d72ec0fa5e28164965b55a3a3f616d8d94f5f3a5070b97f5c7e5905b78b859520d5f7012e323b0c54a034dc3ac526e961703a0d8f798992fb29b
-  data.tar.gz: ba69751cc11872bd57fe32f8aa8f5e6202cd0fce3331ba8e8182e9523ac2f8dcdff0f80aa65d9024ff063a5aa436c2c63f5f7fa24fb8197f9c66c0cfff3cdb47
+  metadata.gz: 68d02d089da02ecf3a7aaeb2562c48a6e8c64d14b7c56ec88859fb7d0c8e926054bdc92af26057ffdad0da3fedf6697b26d6c8da59931b05c532cd2aa8aa1864
+  data.tar.gz: 230877f84e6c54a89f7afbeaa47cc8328e52b6b8d51936bd91c11f86954c061ee8772f5d65cae014bc2c82fcae5c8f826fbbf089e31f4688697efb6300bab4aa

data/.travis.yml

@@ -10,6 +10,7 @@ rvm:
 env:
   global:
     - JRUBY_OPTS="--dev -J-Djruby.launch.inproc=true -J-Xmx1024M"
+    - COVERAGE=true
 
 matrix:
   allow_failures:

data/Gemfile

@@ -4,3 +4,8 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in lightio.gemspec
 gemspec
+
+group :test do
+  gem 'coveralls', require: false
+end
+

data/Gemfile.lock

@@ -1,13 +1,21 @@
 PATH
   remote: .
   specs:
-    lightio (0.1.1)
+    lightio (0.2.0)
       nio4r (~> 2.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    coveralls (0.8.21)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.14.1)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.4)
+      tins (~> 1.6)
     diff-lcs (1.3)
+    docile (1.1.5)
+    json (2.1.0)
     nio4r (2.1.0)
     rake (10.1.0)
     rspec (3.7.0)
@@ -23,12 +31,22 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.0)
+    simplecov (0.14.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    term-ansicolor (1.6.0)
+      tins (~> 1.0)
+    thor (0.19.4)
+    tins (1.16.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.16)
+  coveralls
   lightio!
   rake (~> 10.0)
   rspec (~> 3.0)

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 jjy
+Copyright (c) 2017 Jiang Jinyang
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -2,7 +2,8 @@
 
 
 [![Gem Version](https://badge.fury.io/rb/lightio.svg)](http://rubygems.org/gems/lightio)
-[![Build Status](https://travis-ci.org/jjyr/lightio.svg?branch=master)](https://travis-ci.org/jjyr/lightio)
+[![Build Status](https://travis-ci.org/socketry/lightio.svg?branch=master)](https://travis-ci.org/socketry/lightio)
+[![Coverage Status](https://coveralls.io/repos/github/socketry/lightio/badge.svg?branch=master)](https://coveralls.io/github/socketry/lightio?branch=master)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jjyr/lightio/blob/master/LICENSE.txt)
 
 LightIO is a ruby networking library, that combines ruby fiber and fast IO event loop.
@@ -30,33 +31,15 @@ Or install it yourself as:
 
     $ gem install lightio
 
-## Usage
-
-``` ruby
-require 'lightio'
-
-start = Time.now
-
-beams = 1000.times.map do
-  # LightIO::Beam is a thread-like executor, use it instead Thread
-  LightIO::Beam.new do
-    # do some io operations in beam
-    LightIO.sleep(1)
-  end
-end
-
-beams.each(&:join)
-seconds = Time.now - start
-puts "1000 beams take #{seconds - 1} seconds to create"
-```
-
-View more [examples](/examples).
-
 ## Documentation
 
-See [wiki](https://github.com/jjyr/lightio/wiki) for more information
+[Please see LightIO Wiki](https://github.com/jjyr/lightio/wiki) for more information.
 
-[API Documentation](http://www.rubydoc.info/gems/lightio/frames)
+The following documentations is also usable:
+
+* [Basic usage](https://github.com/socketry/lightio/wiki/Basic-Usage)
+* [YARD documentation](http://www.rubydoc.info/gems/lightio/frames)
+* [Examples](/examples)
 
 ## Discussion
 
@@ -76,6 +59,8 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jjyr/l
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+Copyright, 2017, by [Jiang Jinyang](http://justjjy.com/)
+
 ## Code of Conduct
 
 Everyone interacting in the Lightio project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/lightio/blob/master/CODE_OF_CONDUCT.md).

data/examples/echo_server.rb

@@ -0,0 +1,38 @@
+# Example from https://github.com/socketry/nio4r/blob/master/examples/echo_server.rb
+# rewrite it in lightio for demonstrate
+
+require 'lightio'
+
+class EchoServer
+  def initialize(host, port)
+    @server = LightIO::TCPServer.new(host, port)
+  end
+
+  def run
+    while (socket = @server.accept)
+      _, port, host = socket.peeraddr
+      puts "accept connection from #{host}:#{port}"
+
+      # LightIO::Beam is lightweight executor, provide thread-like interface
+      # just start new beam for per socket
+      LightIO::Beam.new(socket) do |socket|
+        loop do
+          echo(socket)
+        end
+      end
+    end
+  end
+
+  def echo(socket)
+    data = socket.readpartial(4096)
+    socket.write(data)
+  rescue EOFError
+    _, port, host = socket.peeraddr
+    puts "*** #{host}:#{port} disconnected"
+    socket.close
+    raise
+  end
+end
+
+
+EchoServer.new('localhost', 3000).run if __FILE__ == $0

data/examples/echo_server_with_raw_socket.rb

@@ -13,7 +13,7 @@ class EchoServer
   def run
     # wait server until readable
     server_watcher = LightIO::Watchers::IO.new(@server, :r)
-    while server_watcher.wait_read
+    while server_watcher.wait_readable
       socket = @server.accept
       _, port, host = socket.peeraddr
       puts "accept connection from #{host}:#{port}"
@@ -23,7 +23,7 @@ class EchoServer
       LightIO::Beam.new(socket) do |socket|
         socket_watcher = LightIO::Watchers::IO.new(socket, :r)
         begin
-          while socket_watcher.wait_read
+          while socket_watcher.wait_readable
             echo(socket)
           end
         rescue EOFError

data/lib/lightio.rb

@@ -3,6 +3,7 @@ require 'lightio/version'
 require 'lightio/errors'
 require 'lightio/core'
 require 'lightio/watchers'
+require 'lightio/wrap'
 require 'lightio/library'
 
 # LightIO provide light-weight executor: LightIO::Beam and batch io libraries,

data/lib/lightio/core.rb

@@ -1,11 +1,11 @@
 # Core
-require 'lightio/core/ioloop'
-require 'lightio/core/light_fiber'
-require 'lightio/core/future'
-require 'lightio/core/beam'
+require_relative 'core/ioloop'
+require_relative 'core/light_fiber'
+require_relative 'core/future'
+require_relative 'core/beam'
 
 # LightIO::Core include core classes: Beam, IOloop, Future
 #
 # view examples for clues
 module LightIO::Core
-end
+end

data/lib/lightio/core/backend/nio.rb

@@ -107,9 +107,7 @@ module LightIO::Core
       def handle_selectables
         @selector.select(0) do |monitor|
           # invoke callback if io is ready
-          if monitor.readiness
-            monitor.value.call(monitor.io)
-          end
+          monitor.value.call(monitor.io)
         end
       end
 

data/lib/lightio/core/beam.rb

@@ -17,6 +17,16 @@ module LightIO::Core
   #   b.alive? # false
   class Beam < LightFiber
 
+    # special class for simulate Thread#raise for Beam
+    class BeamError
+      attr_reader :error, :parent
+
+      def initialize(error)
+        @error = error
+        @parent = Beam.current
+      end
+    end
+
     # Create a new beam
     #
     # Beam is light-weight executor, provide thread-like interface
@@ -94,6 +104,14 @@ module LightIO::Core
       self
     end
 
+    # Fiber not provide raise method, so we have to simulate one
+    # @param [BeamError]  error currently only support raise BeamError
+    def raise(error)
+      super unless error.is_a?(BeamError)
+      self.parent = error.parent if error.parent
+      raise error.error
+    end
+
     class << self
 
       # Schedule beams

data/lib/lightio/core/future.rb

@@ -22,18 +22,22 @@ module LightIO::Core
     #
     # use this method to set back result
     def transfer(value=nil)
-      raise Error, "state error" if done?
+      raise LightIO::Error, "state error" if done?
       @value = value
       done!
       @light_fiber.transfer if @light_fiber
     end
 
+    def value=(value)
+      transfer(value)
+    end
+
     # Get value
     #
     # this method will block current beam/fiber, until future result is set.
     def value
       return @value if done?
-      raise Error, 'already used' if @light_fiber
+      raise LightIO::Error, 'already used' if @light_fiber
       @light_fiber = LightFiber.current
       @ioloop.transfer
       @value

data/lib/lightio/core/ioloop.rb

@@ -38,13 +38,20 @@ module LightIO::Core
       future = Future.new
       # add watcher to loop
       id = Object.new
-      watcher.set_callback {future.transfer id}
+      watcher.set_callback {|err| future.transfer([id, err])}
       watcher.start(self)
       # trigger a fiber switch
       # wait until watcher is ok
       # then do work
-      if (result = future.value) != id
+      response_id, err = future.value
+      if response_id != id
         raise InvalidTransferError, "expect #{id}, but get #{result}"
+      elsif err
+        # if future return a err
+        # simulate Thread#raise to Beam , that we can shutdown beam blocking by socket accepting
+        # transfer back to which beam occur this err
+        # not sure this is a right way to do it
+        LightIO::Core::Beam.current.raise(err)
       end
     end
 

data/lib/lightio/library.rb

@@ -1,6 +1,8 @@
-require 'lightio/library/queue'
-require 'lightio/library/kernel_ext'
-require 'lightio/library/timeout'
+require_relative 'library/queue'
+require_relative 'library/kernel_ext'
+require_relative 'library/timeout'
+require_relative 'library/io'
+require_relative 'library/socket'
 
 module LightIO
   # Library include modules can cooperative with LightIO::Beam

data/lib/lightio/library/io.rb

@@ -0,0 +1,79 @@
+require 'forwardable'
+module LightIO::Library
+  class IO
+    include LightIO::Wrap::Wrapper
+    wrap ::IO
+
+    extend Forwardable
+    def_delegators :@io_watcher, :wait, :wait_readable, :wait_writable
+
+    wrap_blocking_methods :read, :write, exception_symbol: false
+
+    alias_method :<<, :write
+
+    def read(length=nil, outbuf=nil)
+      raise ArgumentError, "negative length #{length} given" if length && length < 0
+      (outbuf ||= "").clear
+      loop do
+        readlen = length.nil? ? 4096 : length - outbuf.size
+        begin
+          outbuf << wait_nonblock(:read_nonblock, readlen, exception_symbol: false)
+          if length == outbuf.size
+            return outbuf
+          end
+        rescue EOFError
+          return outbuf
+        end
+      end
+    end
+
+    def readpartial(maxlen, outbuf=nil)
+      (outbuf ||= "").clear
+      outbuf << wait_nonblock(:read_nonblock, maxlen, exception_symbol: false)
+      outbuf
+    end
+
+    class << self
+      def open(*args)
+        io = self.new(*args)
+        yield io
+      ensure
+        io.close if io.respond_to? :close
+      end
+
+      def pipe(*args)
+        r, w = raw_class.pipe
+        if block_given?
+          begin
+            return yield r, w
+          ensure
+            w.close
+            r.close
+          end
+        end
+        [IO._wrap(r), IO._wrap(w)]
+      end
+
+      def select(read_fds, write_fds=nil, _except_fds=nil, timeout=nil)
+        timer = 0
+        # run once ioloop
+        LightIO.sleep 0
+        loop do
+          r_fds = (read_fds || []).select {|fd| fd.closed? ? raise(IOError, 'closed stream') : fd.instance_variable_get(:@io_watcher).readable?}
+          w_fds = (write_fds || []).select {|fd| fd.closed? ? raise(IOError, 'closed stream') : fd.instance_variable_get(:@io_watcher).writable?}
+          e_fds = []
+          if r_fds.empty? && w_fds.empty?
+            interval = 0.1
+            LightIO.sleep interval
+            timer += interval
+            if timeout && timer > timeout
+              return nil
+            end
+          else
+            return [r_fds, w_fds, e_fds]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lightio/library/socket.rb

@@ -0,0 +1,93 @@
+require 'socket'
+module LightIO::Library
+
+  class BasicSocket < IO
+    include LightIO::Wrap::Wrapper
+    wrap ::BasicSocket
+
+    wrap_blocking_methods :recv, :recvmsg, :sendmsg
+
+    class << self
+      def for_fd(fd)
+        Socket._wrap(raw_class.for_fd(fd))
+      end
+    end
+  end
+
+  class Socket < BasicSocket
+    include ::Socket::Constants
+    include LightIO::Wrap::Wrapper
+    wrap ::Socket
+
+    wrap_blocking_methods :connect, :recvfrom
+
+    ## implement ::Socket instance methods
+    def accept
+      socket, addrinfo = wait_nonblock(:accept_nonblock)
+      [Socket._wrap(socket), LightIO::Library::Addrinfo._wrap(addrinfo)]
+    end
+
+    def sys_accept
+      @io_watcher.wait_readable
+      @io.sys_accept
+    end
+
+    # bind addr?
+
+    class << self
+      ## implement ::Socket class methods
+      wrap_methods_run_in_threads_pool :getaddrinfo, :gethostbyaddr, :gethostbyname, :gethostname, :getifaddrs,
+                                       :getnameinfo, :getservbyname
+
+      def socketpair(domain, type, protocol)
+        raw_class.socketpair(domain, type, protocol).map {|s| _wrap(s)}
+      end
+
+      alias_method :pair, :socketpair
+
+      def unix_server_socket(path)
+        if block_given?
+          raw_class.unix_server_socket(path) {|s| yield _wrap(s)}
+        else
+          _wrap(raw_class.unix_server_socket(path))
+        end
+      end
+
+      def ip_sockets_port0(ai_list, reuseaddr)
+        raw_class.ip_sockets_port0(ai_list, reuseaddr).map {|s| _wrap(s)}
+      end
+    end
+  end
+
+
+  class IPSocket < BasicSocket
+    include LightIO::Wrap::Wrapper
+    wrap ::IPSocket
+
+    class << self
+      wrap_methods_run_in_threads_pool :getaddress
+    end
+  end
+
+  class TCPSocket < IPSocket
+    include LightIO::Wrap::Wrapper
+    wrap ::TCPSocket
+    wrap_methods_run_in_threads_pool :gethostbyname
+  end
+
+  class TCPServer < TCPSocket
+    include LightIO::Wrap::Wrapper
+    wrap ::TCPServer
+
+    ## implement ::Socket instance methods
+    def accept
+      socket = wait_nonblock(:accept_nonblock)
+      Socket._wrap(socket)
+    end
+
+    def sys_accept
+      @io_watcher.wait_readable
+      @io.sys_accept
+    end
+  end
+end

data/lib/lightio/version.rb

@@ -1,3 +1,3 @@
 module LightIO
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/lightio/watchers.rb

@@ -1,7 +1,7 @@
-require 'lightio/watchers/watcher'
-require 'lightio/watchers/timer'
-require 'lightio/watchers/schedule'
-require 'lightio/watchers/io'
+require_relative 'watchers/watcher'
+require_relative 'watchers/timer'
+require_relative 'watchers/schedule'
+require_relative 'watchers/io'
 
 # Watcher is a abstract struct, for libraries to interact with ioloop
 # see IOloop#wait method

data/lib/lightio/watchers/io.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module LightIO::Watchers
   # LightIO::Watchers::IO provide a NIO::Monitor wrap to manage 'raw' socket / io
   #
@@ -15,14 +17,14 @@ module LightIO::Watchers
     # @param [Socket]  io An IO-able object
     # @param [Symbol]  interests :r, :w, :rw - Is io readable? writeable? or both
     # @return [LightIO::Watchers::IO]
-    def initialize(io, interests)
+    def initialize(io, interests=:rw)
       @io = io
       @ioloop = LightIO::Core::IOloop.current
       @waiting = false
-      @wait_for = nil
       # NIO monitor
       @monitor = @ioloop.add_io_wait(@io, interests) {callback_on_waiting}
       ObjectSpace.define_finalizer(self, self.class.finalizer(@monitor))
+      @error = nil
     end
 
     class << self
@@ -31,63 +33,56 @@ module LightIO::Watchers
       end
     end
 
-    def interests
-      @monitor.interests
-    end
-
-    # Replace current interests
-    def interests=(interests)
-      @monitor.interests = interests
-    end
+    extend Forwardable
+    def_delegators :@monitor, :interests, :interests=, :closed?, :readable?, :writable?, :writeable?
 
-    # Blocking until io interests is satisfied
-    def wait_for(interests)
-      if (self.interests == :w || self.interests == :r) && interests != self.interests
-        raise ArgumentError, "IO interests is #{self.interests}, can't waiting for #{interests}"
-      end
-      @wait_for = interests
-      wait
-    end
 
     # Blocking until io is readable
     # @param [Numeric]  timeout return nil after timeout seconds, otherwise return self
     # @return [LightIO::Watchers::IO, nil]
-    def wait_read(timeout=nil)
-      LightIO::Timeout.timeout(timeout) do
-        wait_for :r
-        self
-      end
-    rescue Timeout::Error
-      nil
+    def wait_readable(timeout=nil)
+      wait timeout, :read
     end
 
-    # Blocking until io is writeable
+    # Blocking until io is writable
     # @param [Numeric]  timeout return nil after timeout seconds, otherwise return self
     # @return [LightIO::Watchers::IO, nil]
-    def wait_write(timeout=nil)
+    def wait_writable(timeout=nil)
+      wait timeout, :write
+    end
+
+    def wait(timeout=nil, mode=:read)
       LightIO::Timeout.timeout(timeout) do
-        wait_for :w
+        interests = {read: :r, write: :w, read_write: :rw}[mode]
+        self.interests = interests
+        wait_in_ioloop
         self
       end
     rescue Timeout::Error
       nil
     end
 
+    def close
+      return if closed?
+      @monitor.close
+      @error = IOError.new('closed stream')
+      callback_on_waiting
+    end
+
 
+    # just implement IOloop#wait watcher interface
     def start(ioloop)
       # do nothing
     end
 
-    # stop io listening
-    def close
-      @monitor.close
+    def set_callback(&blk)
+      @callback = blk
     end
 
-    def close?
-      @monitor.close?
-    end
+    private
 
-    def wait
+    # Blocking until io interests is satisfied
+    def wait_in_ioloop
       raise LightIO::Error, "Watchers::IO can't cross threads" if @ioloop != LightIO::Core::IOloop.current
       raise EOFError, "can't wait closed IO watcher" if @monitor.closed?
       @waiting = true
@@ -95,22 +90,24 @@ module LightIO::Watchers
       @waiting = false
     end
 
-    def set_callback(&blk)
-      @callback = blk
-    end
-
-    private
-
     def callback_on_waiting
       # only call callback on waiting
-      callback.call if @waiting && io_is_ready?
+      return unless @waiting && io_is_ready?
+      if @error
+        # if error occurred in io waiting, send it to callback, see IOloop#wait
+        callback.call(LightIO::Core::Beam::BeamError.new(@error))
+      else
+        callback.call
+      end
     end
 
     def io_is_ready?
-      if @wait_for == :r
-        @monitor.readable?
-      elsif @wait_for == :w
-        @monitor.writeable?
+      if interests == :r
+        readable?
+      elsif interests == :w
+        writeable?
+      else
+        readable? || writeable?
       end
     end
   end

data/lib/lightio/wrap.rb

@@ -0,0 +1,132 @@
+module LightIO::Wrap
+  WRAPPERS = {}
+  module Wrapper
+    # wrap raw ruby io objects
+    #
+    # @param [IO, Socket]  io raw ruby io object
+    def initialize(io=nil)
+      @io ||= io
+      @io_watcher ||= LightIO::Watchers::IO.new(@io)
+    end
+
+    def method_missing(method, *args)
+      @io.public_send(method, *args)
+    end
+
+    def close(*args)
+      # close watcher before io closed
+      @io_watcher.close
+      @io.close(*args)
+    end
+
+    def shutdown(*args)
+      # close watcher before io shutdown
+      @io_watcher.close
+      @io.shutdown(*args)
+    end
+
+    protected
+    def _wrap(io=nil)
+      @io ||= io
+      @io_watcher ||= LightIO::Watchers::IO.new(@io)
+    end
+
+    # wait io nonblock method
+    #
+    # @param [Symbol]  method method name, example: wait_nonblock
+    # @param [args] args arguments pass to method
+    def wait_nonblock(method, *args, exception_symbol: true)
+      loop do
+        begin
+          result = if RUBY_VERSION > "2.3" && exception_symbol
+                     @io.__send__(method, *args, exception: false)
+                   else
+                     @io.__send__(method, *args)
+                   end
+          case result
+            when :wait_readable
+              @io_watcher.wait_readable
+            when :wait_writable
+              @io_watcher.wait_writable
+            else
+              return result
+          end
+        rescue IO::WaitReadable
+          @io_watcher.wait_readable
+        rescue IO::WaitWritable
+          @io_watcher.wait_writable
+        end
+      end
+    end
+
+    # both works in class scope and singleton class scope
+    module SingletonClassCommonMethods
+      protected
+      # run method in thread pool for performance
+      def wrap_methods_run_in_threads_pool(*args)
+        #TODO
+      end
+    end
+
+    module ClassMethods
+      # Wrap raw io objects
+      def _wrap(io)
+        # In case ruby stdlib return already patched Sockets, just do nothing
+        if io.is_a? self
+          io
+        else
+          # old new
+          obj = allocate
+          obj.send(:initialize, io)
+          obj
+        end
+      end
+
+      # override new method, return wrapped class
+      def new(*args)
+        io = raw_class.new(*args)
+        _wrap(io)
+      end
+
+      include SingletonClassCommonMethods
+
+      protected
+      # wrap blocking method with "#{method}_nonblock"
+      #
+      # @param [Symbol]  method method name, example: wait
+      def wrap_blocking_method(method, exception_symbol: true)
+        define_method method do |*args|
+          wait_nonblock(:"#{method}_nonblock", *args, exception_symbol: exception_symbol)
+        end
+      end
+
+      def wrap_blocking_methods(*methods, exception_symbol: true)
+        methods.each {|m| wrap_blocking_method(m, exception_symbol: exception_symbol)}
+      end
+
+      attr_reader :raw_class
+
+      # Set wrapped class
+      def wrap(raw_class)
+        @raw_class=raw_class
+        WRAPPERS[raw_class] = self
+      end
+
+      def method_missing(method, *args)
+        raw_class.public_send(method, *args)
+      end
+    end
+
+    class << self
+      def new_and_wrap(*args)
+        io = raw_class.new(*args)
+        _wrap(io)
+      end
+
+      def included(base)
+        base.send :extend, ClassMethods
+        base.singleton_class.send :extend, SingletonClassCommonMethods
+      end
+    end
+  end
+end

data/lightio.gemspec

@@ -6,7 +6,7 @@ require "lightio/version"
 Gem::Specification.new do |spec|
   spec.name          = "lightio"
   spec.version       = LightIO::VERSION
-  spec.authors       = ["jjy"]
+  spec.authors       = ["Jiang Jinyang"]
   spec.email         = ["jjyruby@gmail.com"]
 
   spec.summary       = %q{LightIO is a ruby networking library, that combines ruby fiber and fast IO event loop.}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightio
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
-- jjy
+- Jiang Jinyang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-11 00:00:00.000000000 Z
+date: 2017-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -87,6 +87,7 @@ files:
 - bin/console
 - bin/setup
 - examples/beams.rb
+- examples/echo_server.rb
 - examples/echo_server_with_raw_socket.rb
 - lib/lightio.rb
 - lib/lightio/core.rb
@@ -97,8 +98,10 @@ files:
 - lib/lightio/core/light_fiber.rb
 - lib/lightio/errors.rb
 - lib/lightio/library.rb
+- lib/lightio/library/io.rb
 - lib/lightio/library/kernel_ext.rb
 - lib/lightio/library/queue.rb
+- lib/lightio/library/socket.rb
 - lib/lightio/library/timeout.rb
 - lib/lightio/version.rb
 - lib/lightio/watchers.rb
@@ -106,6 +109,7 @@ files:
 - lib/lightio/watchers/schedule.rb
 - lib/lightio/watchers/timer.rb
 - lib/lightio/watchers/watcher.rb
+- lib/lightio/wrap.rb
 - lightio.gemspec
 homepage: https://github.com/jjyr/lightio
 licenses: