ls4 0.9.0

data/lib/ls4/default.rb

@@ -0,0 +1,26 @@
+#
+#  LS4
+#  Copyright (C) 2010-2011  FURUHASHI Sadayuki
+#
+#  This program 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.
+#
+#  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+module LS4
+
+
+CS_DEFAULT_PORT = 18700
+DS_DEFAULT_PORT = 18900
+GW_DEFAULT_PORT = 18800
+
+
+end

data/lib/ls4/lib/cclog.rb

@@ -0,0 +1,220 @@
+#
+# CCLog
+# Copyright (c) 2010 FURUHASHI Sadayuki
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+class CCLog
+	module TTYColor
+		RESET   = "\033]R"
+		CRE     = "\033[K"
+		CLEAR   = "\033c"
+		NORMAL  = "\033[0;39m"
+		RED     = "\033[1;31m"
+		GREEN   = "\033[1;32m"
+		YELLOW  = "\033[1;33m"
+		BLUE    = "\033[1;34m"
+		MAGENTA = "\033[1;35m"
+		CYAN    = "\033[1;36m"
+		WHITE   = "\033[1;37m"
+	end
+
+	LEVEL_TRACE = 0
+	LEVEL_DEBUG = 1
+	LEVEL_INFO  = 2
+	LEVEL_WARN  = 3
+	LEVEL_ERROR = 4
+	LEVEL_FATAL = 5
+
+	def initialize(level = LEVEL_TRACE, out = $stdout)
+		if out.tty?
+			enable_color
+		else
+			disable_color
+		end
+		@level = level
+		@out = out
+	end
+
+	def enable_color
+		@color_trace = TTYColor::BLUE
+		@color_debug = TTYColor::WHITE
+		@color_info  = TTYColor::GREEN
+		@color_warn  = TTYColor::YELLOW
+		@color_error = TTYColor::MAGENTA
+		@color_fatal = TTYColor::RED
+		@color_reset = TTYColor::NORMAL
+	end
+
+	def disable_color
+		@color_trace = ''
+		@color_debug = ''
+		@color_info  = ''
+		@color_warn  = ''
+		@color_error = ''
+		@color_fatal = ''
+		@color_reset = ''
+	end
+
+	attr_accessor :out
+	attr_accessor :level
+
+	def on_trace(&block)
+		return if @level > LEVEL_TRACE
+		block.call if block
+	end
+
+	def trace(*args, &block)
+		return if @level > LEVEL_TRACE
+		args << block.call if block
+		msg = args.join
+		puts "#{@color_trace}#{caller_line(1,true)}: #{msg}#{@color_reset}"
+	end
+	alias TRACE trace
+
+	def on_debug(&block)
+		return if @level > LEVEL_DEBUG
+		block.call if block
+	end
+
+	def debug(*args, &block)
+		return if @level > LEVEL_DEBUG
+		args << block.call if block
+		msg = args.join
+		puts "#{@color_debug}#{caller_line(1,true)}: #{msg}#{@color_reset}"
+	end
+	alias DEBUG debug
+
+	def debug_backtrace(backtrace=$!.backtrace)
+		return if @level > LEVEL_DEBUG
+		backtrace.each {|msg|
+			puts "#{@color_debug}#{caller_line(4,true)}: #{msg}#{@color_reset}"
+		}
+		nil
+	end
+
+	def on_info(&block)
+		return if @level > LEVEL_INFO
+		block.call if block
+	end
+
+	def info(*args, &block)
+		return if @level > LEVEL_INFO
+		args << block.call if block
+		msg = args.join
+		puts "#{@color_info}#{caller_line(1,true)}: #{msg}#{@color_reset}"
+	end
+	alias INFO info
+
+	def info_backtrace(backtrace=$!.backtrace)
+		return if @level > LEVEL_INFO
+		backtrace.each {|msg|
+			puts "#{@color_info}#{caller_line(4,true)}: #{msg}#{@color_reset}"
+		}
+		nil
+	end
+
+	def on_warn(&block)
+		return if @level > LEVEL_WARN
+		block.call if block
+	end
+
+	def warn(*args, &block)
+		return if @level > LEVEL_WARN
+		args << block.call if block
+		msg = args.join
+		puts "#{@color_warn}#{caller_line(1)}: #{msg}#{@color_reset}"
+	end
+	alias WARN warn
+
+	def warn_backtrace(backtrace=$!.backtrace)
+		return if @level > LEVEL_WARN
+		backtrace.each {|msg|
+			puts "#{@color_warn}#{caller_line(4)}: #{msg}#{@color_reset}"
+		}
+		nil
+	end
+
+	def on_error(&block)
+		return if @level > LEVEL_ERROR
+		block.call if block
+	end
+
+	def error(*args, &block)
+		return if @level > LEVEL_ERROR
+		args << block.call if block
+		msg = args.join
+		puts "#{@color_error}#{caller_line(1)}: #{msg}#{@color_reset}"
+	end
+	alias ERROR error
+
+	def error_backtrace(backtrace=$!.backtrace)
+		return if @level > LEVEL_ERROR
+		backtrace.each {|msg|
+			puts "#{@color_error}#{caller_line(4)}: #{msg}#{@color_reset}"
+		}
+		nil
+	end
+
+	def on_fatal(&block)
+		return if @level > LEVEL_FATAL
+		block.call if block
+	end
+
+	def fatal(*args, &block)
+		return if @level > LEVEL_FATAL
+		args << block.call if block
+		msg = args.join
+		puts "#{@color_fatal}#{caller_line(1)}: #{msg}#{@color_reset}"
+	end
+	alias FATAL fatal
+
+	def fatal_backtrace(backtrace=$!.backtrace)
+		return if @level > LEVEL_FATAL
+		backtrace.each {|msg|
+			puts "#{@color_fatal}#{caller_line(4)}: #{msg}#{@color_reset}"
+		}
+		nil
+	end
+
+	def puts(msg)
+		@out.puts(msg)
+		@out.flush
+		msg
+	rescue
+		# FIXME
+		nil
+	end
+
+	private
+	def caller_line(level, debug = false)
+		line = caller(level+1)[0]
+		if match = /^(.+?):(\d+)(?::in `(.*)')?/.match(line)
+			if debug
+				"#{match[1]}:#{match[2]}:#{match[3]}"
+			else
+				"#{match[1]}:#{match[2]}"
+			end
+		else
+			""
+		end
+	end
+end
+

data/lib/ls4/lib/ebus.rb

@@ -0,0 +1,553 @@
+#
+# EventBus
+# Copyright (c) 2010 FURUHASHI Sadayuki
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+require 'forwardable'
+require 'singleton'
+
+class EventBus
+	def self.bus(&block)
+		Class.new(Bus, &block)
+	end
+
+	class SlotError < NameError
+	end
+
+	class Slot
+	end
+
+	class CallSlot < Slot
+		def initialize(bus, name)
+			@bus = bus
+			@name = name
+			@method = nil
+		end
+
+		attr_reader :method
+		attr_reader :name
+
+		def connect(method=nil, &block)
+			if @method
+				raise ::EventBus::SlotError.new("slot already connected", @name)
+			end
+			method ||= block
+			@method = method
+			@bus
+		end
+
+		def disconnect!
+			@method = nil
+			@bus
+		end
+
+		def call(*args, &block)
+			unless @method
+				raise ::EventBus::SlotError.new("slot not connected", @name)
+			end
+			@bus.ebus_call_log(@method, args, &block)
+			@method.call(*args, &block)
+		end
+
+		alias signal call
+
+		def to_s
+			m = @method.inspect[/\#\<[^\:]*\:\s?(.+)\>/, 1]
+			unless m
+				m = m.to_s
+			end
+			"#<slot :#{@name} => #{m}>"
+		end
+	end
+
+	class SignalSlot < Slot
+		def initialize(bus, name)
+			@bus = bus
+			@name = name
+			@methods = []
+		end
+
+		attr_reader :methods
+		attr_reader :name
+
+		def connect(method=nil, &block)
+			method ||= block
+			unless @methods.include?(method)
+				@methods << method
+			end
+			@bus
+		end
+
+		def disconnect!
+			@methods.clear
+			@bus
+		end
+
+		def call(*args, &block)
+			@bus.ebus_signal_log(methods, args, &block)
+			methods.each {|block|
+				begin
+					block.call(*args, &block)
+				rescue => err
+					@bus.ebus_signal_error(err)
+				end
+			}
+			nil
+		end
+
+		alias signal call
+
+		def to_s
+			methods = @methods.map {|m|
+				if s = m.inspect[/\#\<[^\:]*\:\s?(.+)\>/, 1]
+					s
+				else
+					m.to_s
+				end
+			}
+			"#<slot :#{@name} => [#{methods.join(',')}]>"
+		end
+	end
+
+	def self.method2const(mname)
+		mname = mname.to_s
+		mname = mname.gsub(/\?$/,   '__p')
+		mname = mname.gsub(/\!$/,   '__bang')
+		mname = mname.gsub(/\=$/,   '__eq')
+		mname = mname.gsub(/^\[\]/, '__at')
+		mname
+	end
+
+	module DeclarerBase
+		def call_slot(*slots)
+			slots.each {|slot|
+				slot = slot.to_sym
+				s = CallSlot.new(self, slot)
+				c = ::EventBus.method2const(slot)
+				const = :"EBUS_SLOT_#{c}"
+				ebus_def_slot_delegators(const, s)
+			}
+			self
+		end
+
+		def signal_slot(*slots)
+			slots.each {|slot|
+				slot = slot.to_sym
+				s = SignalSlot.new(self, slot)
+				c = ::EventBus.method2const(slot)
+				const = :"EBUS_SLOT_#{c}"
+				ebus_def_slot_delegators(const, s)
+			}
+			self
+		end
+
+		module Methods
+			def connect(slot, method)
+				slot = slot.to_sym
+				__send__("connect_#{slot}", method)
+			end
+
+			def ebus_call_log(method, args, &block)
+			end
+
+			def ebus_signal_log(methods, args, &block)
+			end
+
+			def ebus_signal_error(err)
+			end
+
+			def ebus_all_slots
+				slots = []
+				(class<<self;self;end).module_eval do
+					constants.each {|const|
+						if const.to_s =~ /^EBUS_SLOT_.*/
+							slots << const_get(const)
+						end
+					}
+				end
+				slots
+			end
+
+			def ebus_call_slots
+				ebus_all_slots.select {|s|
+					s.is_a?(CallSlot)
+				}
+			end
+
+			def ebus_signal_slots
+				ebus_all_slots.select {|s|
+					s.is_a?(SignalSlot)
+				}
+			end
+		end
+	end
+
+	module BusMixin
+		include DeclarerBase
+		include DeclarerBase::Methods
+		include ::SingleForwardable
+
+		def ebus_all_slots
+			slots = []
+			constants.each {|const|
+				if const.to_s =~ /^EBUS_SLOT_.*/
+					slots << const_get(const)
+				end
+			}
+			slots
+		end
+
+		def ebus_disconnect!
+			constants.each {|const|
+				if const.to_s =~ /^EBUS_SLOT_.*/
+					slot = const_get(const)
+					slot.disconnect!
+				end
+			}
+			nil
+		end
+
+		private
+		def ebus_def_slot_delegators(const, s)
+			const_set(const, s)
+			def_delegator("self::#{const}", :call, s.name)
+			def_delegator("self::#{const}", :connect, "connect_#{s.name}")
+		end
+	end
+
+	class Bus
+		extend BusMixin
+	end
+
+
+	module ObjectMixin
+		include ::Forwardable
+
+		include DeclarerBase
+
+		def self.extended(mod)
+			methods = DeclarerBase::Methods
+			mod.instance_eval do
+				include methods
+			end
+		end
+
+		private
+		def ebus_def_slot_delegators(const, s)
+			const_set(const, s)
+			def_delegator(const, :call, s.name)
+			def_delegator(const, :connect, "connect_#{s.name}")
+		end
+	end
+
+	class Object
+		extend ObjectMixin
+	end
+
+
+	module SingletonMixin
+		include BusMixin
+
+		def self.extended(mod)
+			mod.instance_eval do
+				include ::Singleton
+			end
+		end
+
+		class ConnectEntry
+			def initialize(bus, slot, mname)
+				@bus = bus
+				@slot = slot
+				@mname = mname
+			end
+			attr_reader :bus
+			attr_reader :slot
+			attr_reader :mname
+		end
+
+		def ebus_connect(bus, *slots)
+			slots.each {|slot|
+				case slot
+				when Symbol
+					ebus_connect_const_set(bus, slot, slot)
+				when String
+					ebus_connect_const_set(bus, slot.to_sym, slot.to_sym)
+				when Hash
+					slot.each_pair {|k,v|
+						ebus_connect_const_set(bus, k.to_sym, v.to_sym)
+					}
+				else
+					raise "slot name must be a Symbol: #{slot.inspect}"
+				end
+			}
+		end
+
+		alias connect ebus_connect
+
+		def ebus_bind!
+			constants.each {|const|
+				if const.to_s =~ /^EBUS_CONNECT_.*/
+					e = const_get(const)
+					if e.bus.is_a?(Symbol)
+						bus = eval("#{e.bus}")
+					else
+						bus = e.bus
+					end
+					bus.__send__("connect_#{e.slot}", instance.method(e.mname))
+				end
+			}
+			self
+		end
+
+		alias bind! ebus_bind!
+
+		private
+		def ebus_connect_const_set(bus, slot, mname)
+			e = ConnectEntry.new(bus, slot, mname)
+			c = ::EventBus.method2const(slot)
+			const_set(:"EBUS_CONNECT_#{c.object_id}_#{c}", e)
+		end
+	end
+
+	class Singleton
+		extend SingletonMixin
+	end
+end
+
+
+if $0 == __FILE__
+	def assert(boolean)
+		unless boolean
+			raise "test failed"
+		end
+	end
+
+	def dump_slots(bus)
+		if bus.is_a?(Class)
+			puts bus.name
+		else
+			puts bus.class.name
+		end
+		bus.ebus_all_slots.each {|s|
+			puts "  #{s}"
+		}
+	end
+
+	module Test01
+		Users = EventBus.bus do
+			call_slot :add
+			call_slot :get
+			call_slot :added?
+			signal_slot :user_added
+		end
+
+		class UserService < EventBus::Singleton
+			def initialize
+				@db = {}
+			end
+
+			def add(uid, name)
+				@db[uid] = name
+				Users.user_added(uid)
+				name
+			end
+
+			def get(uid)
+				@db[uid]
+			end
+
+			def added?(uid)
+				@db.has_key?(uid)
+			end
+
+			connect Users, :add, :get, :added?
+		end
+
+		class UserCounter < EventBus::Singleton
+			def initialize
+				@count = 0
+			end
+
+			def on_add_user(uid)
+				@count += 1
+			end
+
+			attr_reader :count
+
+			connect Users, :user_added => :on_add_user
+
+			call_slot :get_count
+			connect self, :get_count => :count
+		end
+
+		UserService.bind!
+		UserCounter.bind!
+
+		dump_slots(Users)
+		dump_slots(UserCounter)
+
+		Users.add(0, "frsyuki")
+		Users.add(1, "viver")
+		assert Users.get(0) == "frsyuki"
+		assert Users.get(1) == "viver"
+		assert Users.added?(0) == true
+		assert Users.added?(1) == true
+		assert UserCounter.instance.count == 2
+		assert UserCounter.get_count == 2
+	end
+
+
+	module Test02
+		class Users < EventBus::Bus
+			call_slot :add
+			call_slot :get
+			call_slot :added?
+			signal_slot :user_added
+		end
+
+		class UserService
+			extend EventBus::SingletonMixin
+
+			def initialize
+				@db = {}
+			end
+
+			def add(uid, name)
+				@db[uid] = name
+				Users.user_added(uid)
+				name
+			end
+
+			def get(uid)
+				@db[uid]
+			end
+
+			def added?(uid)
+				@db.has_key?(uid)
+			end
+
+			connect Users, :add, :get, :added?
+		end
+
+		class UserCounter
+			extend EventBus::BusMixin
+
+			def initialize
+				@count = 0
+			end
+
+			def on_add_user(uid)
+				@count += 1
+			end
+
+			attr_reader :count
+		end
+
+		ucouter = UserCounter.new
+
+		UserService.bind!
+		Users.connect(:user_added, ucouter.method(:on_add_user))
+
+		dump_slots(Users)
+
+		Users.add(0, "frsyuki")
+		Users.add(1, "viver")
+		assert Users.get(0) == "frsyuki"
+		assert Users.get(1) == "viver"
+		assert Users.added?(0) == true
+		assert Users.added?(1) == true
+		assert ucouter.count == 2
+	end
+
+
+	module Test03
+		class Button < EventBus::Object
+			def press
+				on_press
+			end
+
+			call_slot :on_press
+		end
+
+		class App
+			def initialize
+				@pressed = false
+			end
+
+			def draw
+				a = Button.new
+				a.connect(:on_press, method(:on_press))
+				dump_slots(a)
+				a
+			end
+
+			def on_press
+				@pressed = true
+			end
+
+			attr_reader :pressed
+		end
+
+		app = App.new
+		b = app.draw
+		b.on_press
+
+		assert app.pressed == true
+	end
+
+
+	module Test04
+		class Button
+			extend EventBus::ObjectMixin
+
+			def press
+				on_press
+			end
+
+			call_slot :on_press
+		end
+
+		class App
+			def initialize
+				@pressed = false
+			end
+
+			def draw
+				a = Button.new
+				a.connect(:on_press, method(:on_press))
+				dump_slots(a)
+				a
+			end
+
+			def on_press
+				@pressed = true
+			end
+
+			attr_reader :pressed
+		end
+
+		app = App.new
+		b = app.draw
+		b.on_press
+
+		assert app.pressed == true
+	end
+end
+