barlume 0.0.1.rc.1

data/README.md

@@ -0,0 +1,2 @@
+barlume - a dim light over asynchronous I/O land
+================================================

data/barlume.gemspec

@@ -0,0 +1,18 @@
+Kernel.load 'lib/barlume/version.rb'
+
+Gem::Specification.new {|s|
+	s.name         = 'barlume'
+	s.version      = Barlume.version
+	s.author       = 'meh.'
+	s.email        = 'meh@paranoici.org'
+	s.homepage     = 'http://github.com/meh/barlume'
+	s.platform     = Gem::Platform::RUBY
+	s.summary      = 'A dim light over asynchronous I/O land.'
+
+	s.files         = `git ls-files`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.require_paths = ['lib']
+
+	s.add_dependency 'ffi'
+}

data/examples/test.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby
+require 'barlume'
+require 'socket'
+
+lantern = Barlume::Lanterna.best
+server  = TCPServer.new 43215
+clients = []
+
+puts "Using #{lantern.name}..."
+
+lantern << server
+
+loop do
+	lantern.readable.each {|lucciola|
+		if lucciola == server
+			server.accept.tap {|client|
+				clients.push(lantern.add(client))
+			}
+		else
+			puts lucciola.readline rescue nil
+
+			if lucciola.closed?
+				clients.delete(lantern.remove(lucciola))
+			end
+		end
+	}
+end

data/lib/barlume.rb

@@ -0,0 +1,20 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'barlume/lanterna'

data/lib/barlume/lanterna.rb

@@ -0,0 +1,134 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'barlume/lucciola'
+
+module Barlume
+
+class Lanterna
+	class << self
+		%w[select poll epoll kqueue].each {|name|
+			define_method "#{name}?" do
+				const_get(name.capitalize).supported?
+			end
+
+			define_method name do
+				const_get(name.capitalize).new
+			end
+		}
+
+		def best
+			return kqueue if kqueue?
+
+			return epoll if epoll?
+
+			return poll if poll?
+
+			return select
+		end
+
+		def new (*)
+			raise 'unsupported platform' unless supported?
+
+			super
+		end
+	end
+
+	Available = Struct.new(:readable, :writable, :error)
+
+	class Breaker
+		def initialize
+			@pipes = IO.pipe
+		end
+
+		def break
+			@pipes.last.write_nonblock 'x'
+		end
+
+		def flush
+			@pipes.first.read_nonblock 2048 rescue nil
+		end
+
+		def to_io
+			@pipes.first
+		end
+
+		def to_i
+			to_io.to_i
+		end
+	end
+
+	attr_reader :descriptors
+
+	def initialize
+		@breaker       = Breaker.new
+		@descriptors   = []
+		@report_errors = false
+	end
+
+	def name
+		self.class.name[/(?:::)?([^:]*)$/, 1].downcase.to_sym
+	end
+
+	def report_errors?
+		@report_errors
+	end
+
+	def report_errors!
+		@report_errors = true
+	end
+
+	def dont_report_errors!
+		@report_errors = false
+	end
+
+	def break
+		@breaker.break
+	end
+
+	def add (what)
+		Lucciola.wrap(what).tap {|l|
+			return false if @descriptors.member?(l)
+
+			@descriptors.push(l)
+		}
+	end
+
+	def push (*args)
+		args.each { |a| add a }
+
+		self
+	end
+
+	alias << push
+
+	def remove (what)
+		@descriptors.delete(Lucciola.wrap(what))
+	end
+
+	alias delete remove
+end
+
+end
+
+require 'barlume/lanterna/utils'
+require 'barlume/lanterna/select'
+require 'barlume/lanterna/poll'
+require 'barlume/lanterna/epoll'
+require 'barlume/lanterna/kqueue'

data/lib/barlume/lanterna/epoll.rb

@@ -0,0 +1,207 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'ffi'
+
+module Barlume; class Lanterna
+
+class Epoll < Lanterna; begin
+	module C
+		extend FFI::Library
+
+		ffi_lib FFI::Library::LIBC
+
+		class EpollData < FFI::Union
+			layout \
+				:ptr, :pointer,
+				:fd,  :int,
+				:u32, :uint32,
+				:u64, :uint64
+		end
+
+		class EpollEvent < FFI::Struct
+			pack 1
+
+			layout \
+				:events, :uint32,
+				:data,   EpollData
+		end
+
+		Control = FFI::Enum.new([:add, 1, :del, :mod])
+
+		attach_function :epoll_create, [:int], :int
+		attach_function :epoll_create1, [:int], :int
+		attach_function :epoll_ctl, [:int, Control, :int, :pointer], :int
+		attach_function :epoll_wait, [:int, :pointer, :int, :int], :int
+
+		MAX = 4294967295
+
+		EPOLLIN  = 0x001
+		EPOLLPRI = 0x002
+		EPOLLOUT = 0x004
+
+		EPOLLERR  = 0x008
+		EPOLLHUP  = 0x010
+		EPOLLNVAL = 0x020
+
+		EPOLLRDNORM = 0x040
+		EPOLLRDBAND = 0x080
+		EPOLLWRNORM = 0x100
+		EPOLLWRBAND = 0x200
+
+		EPOLLMSG    = 0x0400
+		EPOLLREMOVE = 0x1000
+		EPOLLRDHUP  = 0x2000
+
+		EPOLLONESHOT = 1 << 30
+		EPOLLET      = 1 << 31
+	end
+
+	def self.supported?
+		true
+	end
+
+	def self.new (*)
+		super.tap {|c|
+			ObjectSpace.define_finalizer c, finalizer(c.instance_variable_get :@fd)
+		}
+	end
+
+	def self.finalizer (fd)
+		proc {
+			IO.for_fd(fd).close
+		}
+	end
+
+	def initialize
+		super
+
+		FFI.raise_if((@fd = C.epoll_create1(0)) < 0)
+
+		p = C::EpollEvent.new
+		p[:events] = C::EPOLLIN
+		p[:data][:u32] = C::MAX
+
+		FFI.raise_if(C.epoll_ctl(@fd, :add, @breaker.to_i, p) < 0)
+
+		self.size = 4096
+	end
+
+	def size
+		@events.size / C::EpollEvent.size
+	end
+
+	def size= (n)
+		@events = FFI::MemoryPointer.new C::EpollEvent.size, n
+	end
+
+	def add (what)
+		super.tap {|l|
+			FFI.raise_if(C.epoll_ctl(@fd, :add, l.to_i, C::EpollEvent.new) < 0)
+
+			@last = nil
+		}
+	end
+
+	def remove (what)
+		super.tap {|l|
+			begin
+				FFI.raise_if(C.epoll_ctl(@fd, :del, l.to_i, nil) < 0)
+			rescue Errno::ENOENT; end
+
+			@last = nil
+		}
+	end
+
+	def available (timeout = nil)
+		set :both; epoll timeout
+
+		Available.new(to(:read), to(:write), to(:error))
+	end
+
+	def readable (timeout = nil)
+		set :read; epoll timeout
+
+		if report_errors?
+			[to(:read), to(:error)]
+		else
+			to :read
+		end
+	end
+
+	def writable (timeout = nil)
+		set :write; epoll timeout
+
+		if report_errors?
+			[to(:write), to(:error)]
+		else
+			to :write
+		end
+	end
+
+	def set (what)
+		return if @last == what
+
+		p = C::EpollEvent.new
+		p[:events] = case what
+			when :both  then C::EPOLLIN | C::EPOLLOUT
+			when :read  then C::EPOLLIN
+			when :write then C::EPOLLOUT
+		end
+
+		descriptors.each_with_index {|descriptor, index|
+			p[:data][:u32] = index
+
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, descriptor.to_i, p) < 0)
+		}
+
+		@last = what
+	end
+
+	def to (what)
+		result = []
+		events = case what
+			when :read  then C::EPOLLIN
+			when :write then C::EPOLLOUT
+			when :error then C::EPOLLERR | C::EPOLLHUP
+		end
+
+		0.upto(@length - 1) {|n|
+			p = C::EpollEvent.new(@events + (n * C::EpollEvent.size))
+
+			if p[:data][:u32] != C::MAX && (p[:events] & events).nonzero?
+				result << descriptors[p[:data][:u32]]
+			end
+		}
+
+		result
+	end
+
+	def epoll (timeout = nil)
+		FFI.raise_if((@length = C.epoll_wait(@fd, @events, size, timeout ? timeout * 1000 : -1)) < 0)
+
+		@breaker.flush
+	end
+rescue Exception
+	def self.supported?
+		false
+	end
+end; end
+
+end; end

data/lib/barlume/lanterna/kqueue.rb

@@ -0,0 +1,249 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Barlume; class Lanterna
+
+class Kqueue < Lanterna; begin
+	module C
+		extend FFI::Library
+
+		ffi_lib FFI::Library::LIBC
+
+		class Kevent < FFI::Struct
+			layout \
+				:ident,  :intptr_t,
+				:filter, :short,
+				:flags,  :ushort,
+				:fflags, :uint,
+				:data,   :long,
+				:udata,  :pointer
+		end
+
+		class TimeSpec < FFI::Struct
+			layout \
+				:tv_sec,  :time_t,
+				:tv_nsec, :int
+		end
+
+		attach_function :kqueue, [], :int
+		attach_function :kevent, [:int, :pointer, :int, :pointer, :int, :pointer], :int
+
+		MAX = 4294967295
+
+		EVFILT_READ     =  -1
+		EVFILT_WRITE    =  -2
+		EVFILT_AIO      =  -3
+		EVFILT_VNODE    =  -4
+		EVFILT_PROC     =  -5
+		EVFILT_SIGNAL   =  -6
+		EVFILT_TIMER    =  -7
+		EVFILT_NETDEV   =  -8
+		EVFILT_FS       =  -9
+		EVFILT_LIO      = -10
+		EVFILT_USER     = -11
+		EVFILT_SYSCOUNT =  11
+
+		EV_ADD      = 0x0001
+		EV_DELETE   = 0x0002
+		EV_ENABLE   = 0x0004
+		EV_DISABLE  = 0x0008
+		EV_ONESHOT  = 0x0010
+		EV_CLEAR    = 0x0020
+		EV_RECEIPT  = 0x0040
+		EV_DISPATCH = 0x0080
+		EV_SYSFLAGS = 0xF000
+		EV_FLAG1    = 0x2000
+		EV_EOF      = 0x8000
+		EV_ERROR    = 0x4000
+
+		def self.EV_SET (event, a, b, c, d, e, f)
+			event[:ident]  = a
+			event[:filter] = b
+			event[:flags]  = c
+			event[:fflags] = d
+			event[:data]   = e
+			event[:udata]  = f
+
+			event
+		end
+	end
+
+	def self.supported?
+		true
+	end
+
+	def self.new (*)
+		super.tap {|c|
+			ObjectSpace.define_finalizer c, finalizer(c.instance_variable_get :@fd)
+		}
+	end
+
+	def self.finalizer (fd)
+		proc {
+			IO.for_fd(fd).close
+		}
+	end
+
+	def initialize
+		super
+
+		FFI.raise_if((@fd = C.kqueue) < 0)
+
+		if C.kevent(@fd, C::EV_SET(C::Kevent.new, @breaker.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, FFI::Pointer.new(C::MAX)), 1, nil, 0, nil) < 0
+			FFI.raise
+		end
+
+		self.size = 4096
+	end
+
+	def size
+		@events.size / C::Kevent.size
+	end
+
+	def size= (n)
+		@events = FFI::MemoryPointer.new C::Kevent.size, n
+	end
+
+	def add (*)
+		super.tap {
+			@last = nil
+		}
+	end
+
+	def remove (what)
+		super.tap {|l|
+			begin
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(C::Kevent.new, what.to_i, C::EVFILT_READ, C::EV_DELETE | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
+			rescue Errno::ENOENT; end
+
+			begin
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(C::Kevent.new, what.to_i, C::EVFILT_WRITE, C::EV_DELETE | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
+			rescue Errno::ENOENT; end
+
+			@last = nil
+		}
+	end
+
+	def available (timeout = nil)
+		set :both; kevent timeout
+
+		Available.new(to(:read), to(:write), to(:error))
+	end
+
+	def readable (timeout = nil)
+		set :read; kevent timeout
+
+		if report_errors?
+			[to(:read), to(:error)]
+		else
+			to :read
+		end
+	end
+
+	def writable (timeout = nil)
+		set :write; kevent timeout
+
+		if report_errors?
+			[to(:write), to(:error)]
+		else
+			to :write
+		end
+	end
+
+	def set (what)
+		return if @last == what
+
+		ev = C::Kevent.new
+
+		if what == :read
+			descriptors.each_with_index {|descriptor, index|
+				index = FFI::Pointer.new(index)
+
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_DISABLE, 0, 0, index), 1, nil, 0, nil) < 0)
+			}
+		elsif what == :write
+			descriptors.each_with_index {|descriptor, index|
+				index = FFI::Pointer.new(index)
+
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_DISABLE, 0, 0, index), 1, nil, 0, nil) < 0)
+			}
+		else
+			descriptors.each_with_index {|descriptor, index|
+				index = FFI::Pointer.new(index)
+
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
+			}
+		end
+
+		@last = what
+	end
+
+	def to (what)
+		result = []
+
+		if what == :error
+			0.upto(@length - 1) {|n|
+				p     = C::Kevent.new(@events + (n * C::Kevent.size))
+				index = p[:udata].address
+
+				if p != index && (p[:flags] & C::EV_ERROR).nonzero?
+					result << descriptors[index]
+				end
+			}
+		else
+			filter = case what
+				when :read  then C::EVFILT_READ
+				when :write then C::EVFILT_WRITE
+			end
+
+			0.upto(@length - 1) {|n|
+				p     = C::Kevent.new(@events + (n * C::Kevent.size))
+				index = p[:udata].address
+
+				if index != C::MAX && p[:filter] == filter
+					result << descriptors[index]
+				end
+			}
+		end
+
+		result
+	end
+
+	def kevent (timeout = nil)
+		if timeout
+			timeout = C::TimeSpec.new.tap {|t|
+				t[:tv_sec]  = timeout.to_i
+				t[:tv_nsec] = (timeout - timeout.to_i) * 1000
+			}
+		end
+
+		FFI.raise_if((@length = C.kevent(@fd, nil, 0, @events, size, timeout)) < 0)
+
+		@breaker.flush
+	end
+rescue Exception
+	def self.supported?
+		false
+	end
+end; end
+
+end; end

data/lib/barlume/lanterna/poll.rb

@@ -0,0 +1,177 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'ffi'
+
+module Barlume; class Lanterna
+
+class Poll < Lanterna; begin
+	module C
+		extend FFI::Library
+
+		ffi_lib FFI::Library::LIBC
+
+		class PollFD < FFI::Struct
+			layout \
+				:fd,      :int,
+				:events,  :short,
+				:revents, :short
+		end
+
+		attach_function :poll, [:pointer, :ulong, :int], :int
+
+		attach_function :malloc, [:size_t], :pointer
+		attach_function :realloc, [:pointer, :size_t], :pointer
+		attach_function :free, [:pointer], :void
+
+		POLLIN  = 0x001
+		POLLPRI = 0x002
+		POLLOUT = 0x004
+
+		POLLERR  = 0x008
+		POLLHUP  = 0x010
+		POLLNVAL = 0x020
+
+		POLLRDNORM = 0x040
+		POLLRDBAND = 0x080
+		POLLWRNORM = 0x100
+		POLLWRBAND = 0x200
+
+		POLLMSG    = 0x0400
+		POLLREMOVE = 0x1000
+		POLLRDHUP  = 0x2000
+	end
+
+	def self.supported?
+		true
+	end
+
+	def initialize
+		super
+
+		@set = FFI::AutoPointer.new(C.malloc(C::PollFD.size), C.method(:free))
+
+		pfd          = C::PollFD.new(@set + 0)
+		pfd[:fd]     = @breaker.to_i
+		pfd[:events] = C::POLLIN
+	end
+
+	def add (what)
+		super.tap {|l|
+			next unless l
+
+			@set.autorelease = false
+			@set = FFI::AutoPointer.new(C.realloc(@set, (descriptors.length + 1) * C::PollFD.size), C.method(:free))
+
+			pfd = C::PollFD.new(@set + descriptors.length * C::PollFD.size)
+			pfd[:fd] = l.to_i
+
+			@last = nil
+		}
+	end
+
+	def remove (what)
+		Lucciola.wrap(what).tap {|l|
+			index   = descriptors.index(l)
+			offset  = (index + 1) * C::PollFD.size
+			pointer = @set + offset
+
+			pointer.write_bytes((pointer + C::PollFD.size).read_bytes((descriptors.length - index) * C::PollFD.size))
+
+			@set.autorelease = false
+			@set = FFI::AutoPointer.new(C.realloc(@set, (descriptors.length) * C::PollFD.size), C.method(:free))
+
+			super(l)
+		}
+	end
+
+	def available (timeout = nil)
+		set :both; poll timeout
+
+		Available.new(to(:read), to(:write), to(:error))
+	end
+
+	def readable (timeout = nil)
+		set :read; poll timeout
+
+		if report_errors?
+			[to(:read), to(:error)]
+		else
+			to :read
+		end
+	end
+
+	def writable (timeout = nil)
+		set :write; poll timeout
+
+		if report_errors?
+			[to(:write), to(:error)]
+		else
+			to :write
+		end
+	end
+
+	def set (what)
+		return if @last == what
+
+		events = case what
+			when :both  then C::POLLIN | C::POLLOUT
+			when :read  then C::POLLIN
+			when :write then C::POLLOUT
+		end
+
+		1.upto(descriptors.length) {|n|
+			pfd = C::PollFD.new(@set + (n * C::PollFD.size))
+			pfd[:events] = events
+		}
+
+		@last = what
+	end
+
+	def to (what)
+		result = []
+		events = case what
+			when :read  then C::POLLIN
+			when :write then C::POLLOUT
+			when :error then C::POLLERR | C::POLLHUP
+		end
+
+		1.upto(descriptors.length) {|n|
+			pfd = C::PollFD.new(@set + (n * C::PollFD.size))
+
+			if (pfd[:revents] & events).nonzero?
+				result << descriptors[n - 1]
+			end
+		}
+
+		result
+	end
+
+	def poll (timeout = nil)
+		FFI.raise_if(C.poll(@set, descriptors.length + 1, timeout ? timeout * 1000 : -1) < 0)
+
+		@breaker.flush
+	end
+rescue Exception
+	def self.supported?
+		false
+	end
+end; end
+
+end; end

data/lib/barlume/lanterna/select.rb

@@ -0,0 +1,83 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Barlume; class Lanterna
+
+class Select < Lanterna
+	def self.supported?
+		true
+	end
+
+	def add (*)
+		super.tap {
+			@descriptors_with_breaker = nil
+		}
+	end
+
+	def remove (*)
+		super.tap {
+			@descriptors_with_breaker = nil
+		}
+	end
+
+	def available (timeout = nil)
+		readable, writable, error = IO.select(descriptors_with_breaker, descriptors, descriptors, timeout)
+
+		if readable && readable.delete(@breaker.to_io)
+			@breaker.flush
+		end
+
+		Available.new(readable || [], writable || [], error || [])
+	end
+
+	def readable (timeout = nil)
+		readable, writable, error = IO.select(descriptors_with_breaker, nil, descriptors, timeout)
+
+		if readable && readable.delete(@breaker.to_io)
+			@breaker.flush
+		end
+
+		if report_errors?
+			[readable || [], error || []]
+		else
+			readable || []
+		end
+	end
+
+	def writable (timeout = nil)
+		readable, writable, error = IO.select([@breaker], descriptors, descriptors, timeout)
+
+		if readable && readable.delete(@breaker.to_io)
+			@breaker.flush
+		end
+
+		if report_errors?
+			[writable || [], error || []]
+		else
+			writable || []
+		end
+	end
+
+private
+	def descriptors_with_breaker
+		@descriptors_with_breaker ||= [@breaker.to_io] + descriptors
+	end
+end
+
+end; end

data/lib/barlume/lanterna/utils.rb

@@ -0,0 +1,48 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'ffi'
+
+module FFI
+	def self.raise
+		value = FFI.errno
+
+		Kernel.raise Errno.constants[FFI.errno].new
+	rescue Exception => e
+		e.backtrace.shift(3)
+
+		Kernel.raise e
+	end
+
+	def self.raise_unless (what)
+		what ? what : FFI.raise
+	rescue Exception => e
+		e.backtrace.shift(1)
+
+		Kernel.raise e
+	end
+
+	def self.raise_if (what)
+		what ? FFI.raise : what
+	rescue Exception => e
+		e.backtrace.shift(1)
+
+		Kernel.raise e
+	end
+end

data/lib/barlume/lucciola.rb

@@ -0,0 +1,108 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'fcntl'
+
+module Barlume
+
+class Lucciola
+	def self.wrap (what)
+		return what if what.is_a? self
+
+		new(what)
+	end
+
+	def initialize (what)
+		@io = what.is_a?(::Integer) ? ::IO.for_fd(what) : what
+
+		unless @io.respond_to? :to_i
+			raise ArgumentError, 'the object must respond to to_i'
+		end
+
+		@fd = @io.to_i
+	end
+
+	def respond_to_missing? (*args)
+		@io.respond_to? *args
+	end
+
+	def method_missing (id, *args, &block)
+		if @io.respond_to? id
+			begin
+				return @io.__send__ id, *args, &block
+			rescue EOFError
+				@closed = true
+
+				raise
+			end
+		end
+
+		super
+	end
+
+	def == (other)
+		to_i == other.to_i
+	end
+
+	alias eql? ==
+
+	def equal? (other)
+		to_io == (other.respond_to?(:to_io) ? other.to_io : other)
+	end
+
+	def hash
+		to_i.hash
+	end
+
+	def closed?
+		@closed or @io.respond_to?(:closed?) ? @io.closed? : false
+	end
+
+	def nonblocking?
+		(@io.fcntl(Fcntl::F_GETFL, 0) & Fcntl::O_NONBLOCK).nonzero?
+	end
+
+	alias asynchronous? nonblocking?
+
+	def blocking?
+		!nonblocking?
+	end
+
+	def blocking!
+		@io.fcntl(Fcntl::F_SETFL, @io.fcntl(Fcntl::F_GETFL, 0) | Fcntl::O_NONBLOCK)
+	end
+
+	def nonblocking!
+		@io.fcntl(Fcntl::F_SETFL, @io.fcntl(Fcntl::F_GETFL, 0) & ~Fcntl::O_NONBLOCK)
+	end
+
+	def to_io
+		@io
+	end
+
+	def to_i
+		@fd
+	end
+
+	def inspect
+		"#<#{self.class.name}: #{to_io.inspect}>"
+	end
+end
+
+end

data/lib/barlume/version.rb

@@ -0,0 +1,24 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Barlume
+	def self.version
+		'0.0.1.rc.1'
+	end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: barlume
+version: !ruby/object:Gem::Version
+  version: 0.0.1.rc.1
+  prerelease: 6
+platform: ruby
+authors:
+- meh.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: meh@paranoici.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- barlume.gemspec
+- examples/test.rb
+- lib/barlume.rb
+- lib/barlume/lanterna.rb
+- lib/barlume/lanterna/epoll.rb
+- lib/barlume/lanterna/kqueue.rb
+- lib/barlume/lanterna/poll.rb
+- lib/barlume/lanterna/select.rb
+- lib/barlume/lanterna/utils.rb
+- lib/barlume/lucciola.rb
+- lib/barlume/version.rb
+homepage: http://github.com/meh/barlume
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A dim light over asynchronous I/O land.
+test_files: []