failirc 0.0.1

data/lib/failirc/server/dispatcher/event.rb

@@ -0,0 +1,113 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc 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.
+#
+# failirc 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 failirc. If not, see <http://www.gnu.org/licenses/>.
+
+module IRC
+
+class Server
+
+class Dispatcher
+
+class Event
+    class Callback
+        attr_reader :method
+        attr_accessor :priority
+
+        def initialize (method, priority=0)
+            @method   = method
+            @priority = priority
+        end
+
+        def call (*args)
+            return @method.call(*args)
+        end
+    end
+
+    attr_reader :types, :chain, :aliases, :dispatcher, :thing, :string
+    attr_accessor :special
+
+    def initialize (dispatcher, chain, thing, string)
+        @dispatcher = dispatcher
+        @chain      = chain
+        @thing      = thing
+        @string     = string
+        @types      = Event.types(dispatcher, chain, string)
+        @aliases    = Event.aliases(dispatcher, chain, types)
+        @callbacks  = Event.callbacks(dispatcher, chain, types)
+    end
+
+    def callbacks
+        if @callbacks
+            return @callbacks
+        else
+            tmp = Event.callbacks(@dispatcher, @chain, @type)
+
+            if tmp
+                return @callbacks = tmp
+            else
+                return []
+            end
+        end
+    end
+
+    def self.types (dispatcher, chain, string)
+        types = []
+
+        dispatcher.events[chain].each_key {|key|
+            if key.class == Regexp && key.match(string)
+                types.push key
+            end
+        }
+
+        return types
+    end
+
+    def self.aliases (dispatcher, chain, types)
+        aliases = []
+
+        dispatcher.aliases[chain].each {|key, value|
+            if types.include?(value)
+                aliases.push key
+            end
+        }
+
+        return aliases
+    end
+
+    def self.callbacks (dispatcher, chain, types)
+        callbacks = []
+
+        if chain == :pre || chain == :post || chain == :default
+            callbacks.insert(-1, *dispatcher.events[chain])
+        else
+            types.each {|type|
+                callbacks.insert(-1, *dispatcher.events[chain][type])
+            }
+        end
+
+        return callbacks
+    end
+end
+
+end
+
+Event = Dispatcher::Event
+
+end
+
+end

data/lib/failirc/server/dispatcher/eventdispatcher.rb

@@ -0,0 +1,196 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc 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.
+#
+# failirc 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 failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/utils'
+require 'failirc/server/dispatcher/event'
+
+module IRC
+
+class Server
+
+class Dispatcher
+
+class EventDispatcher
+    attr_reader :server, :dispatcher, :handling, :aliases, :events
+
+    def initialize (dispatcher)
+        @server     = dispatcher.server
+        @dispatcher = dispatcher
+        @handling   = ThreadSafeHash.new
+
+        @aliases = {
+            :input  => {},
+            :output => {},
+        }
+
+        @events = {
+            :pre     => [],
+            :post    => [],
+            :default => [],
+
+            :custom => {},
+
+            :input  => {},
+            :output => {},
+        }
+    end
+
+    def handle (what, chain, deep, thing)
+        if chain != :input || deep
+            return
+        end
+
+        if what == :start
+            @handling[thing.socket] = true
+        else
+            @handling.delete(thing.socket)
+        end
+    end
+
+    def dispatch (chain, thing, string, deep=false)
+        if !thing
+            return
+        end
+
+        handle(:start, chain, deep, thing)
+
+        event  = Event.new(self, chain, thing, string)
+        result = string
+
+        @events[:pre].each {|callback|
+            event.special = :pre
+
+            if callback.call(event, thing, string) == false
+                handle(:stop, chain, deep, thing)
+                return false
+            end
+        }
+
+        if !event.types.empty?
+            event.special = nil
+
+            event.callbacks.each {|callback|
+                begin
+                    if callback.call(thing, string) == false
+                        handle(:stop, chain, deep, thing)
+                        return false
+                    end
+                rescue Exception => e
+                    self.debug e
+                end
+            }
+        elsif chain == :input
+            @events[:default].each {|callback|
+                event.special = :default
+    
+                if callback.call(event, thing, string) == false
+                    handle(:stop, chain, deep, thing)
+                    return false
+                end
+            }
+        end
+
+        @events[:post].each {|callback|
+            event.special = :post
+
+            if callback.call(event, thing, string) == false
+                handle(:stop, chain, deep, thing)
+                return false
+            end
+        }
+
+        handle(:stop, chain, deep, thing)
+
+        return result
+    end
+
+    def execute (event, *args)
+        if @events[:custom][event]
+            @events[:custom][event].each {|callback|
+                begin
+                    if callback.method.call(*args) == false
+                        return false
+                    end
+                rescue Exception => e
+                    self.debug e
+                end
+            }
+        end
+    end
+
+    def alias (chain, symbol, regex)
+        if !regex
+            @aliases[chain].delete(symbol)
+        elsif !regex.class == Regexp
+            raise 'You have to alias to a Regexp.'
+        else
+            @aliases[chain][symbol] = regex
+        end
+    end
+
+    def register (chain, type, callback, priority=0)
+        if !type
+            events = @events[chain]
+
+            if !events
+                events = @events[chain] = []
+            end
+        else
+            if @aliases[chain]
+                if @aliases[chain][type]
+                    type = @aliases[chain][type]
+                end
+            end
+
+            if !@events[chain]
+                @events[chain] = {}
+            end
+
+            events = @events[chain][type]
+
+            if !events
+                events = @events[chain][type] = []
+            end
+        end
+
+        if !callback
+            events.clear
+        elsif callback.is_a?(Array)
+            callback.each {|callback|
+                register(chain, type, callback)
+            }
+        else
+            if callback.is_a?(Event::Callback)
+                events.push(callback)
+            else
+                events.push(Event::Callback.new(callback, priority))
+            end
+        end
+
+        events.sort! {|a, b|
+            a.priority <=> b.priority
+        }
+    end
+end
+
+end
+
+end
+
+end

data/lib/failirc/server/link.rb

@@ -0,0 +1,50 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc 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.
+#
+# failirc 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 failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/utils'
+
+module IRC
+
+class Server
+
+class Link
+    attr_reader :server, :socket, :listen, :host
+
+    def initialize (server, socket, listen)
+        @server = server
+        @socket = socket
+        @listen = listen
+    end
+
+    def raw (text)
+        @socket.puts text
+    end
+
+    def send (type, *args)
+        callback = @@callbacks[type]
+        callback(args)
+    end
+
+    @@callbacks = {
+    }
+end
+
+end
+
+end

data/lib/failirc/server/links.rb

@@ -0,0 +1,49 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc 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.
+#
+# failirc 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 failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/extensions'
+require 'failirc/server/link'
+
+module IRC
+
+class Server
+
+class Links < ThreadSafeHash
+    attr_reader :server
+
+    def initialize (server)
+        @server = server
+
+        super()
+    end
+
+    def inspect
+        result = ""
+
+        each {|link|
+            result << " #{link.inspect}"
+        }
+
+        return result[1, result.length]
+    end
+end
+
+end
+
+end

data/lib/failirc/server/module.rb

@@ -0,0 +1,103 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc 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.
+#
+# failirc 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 failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/utils'
+
+module IRC
+
+class Server
+
+class Module
+    attr_reader :server
+
+    def initialize (server)
+        @server = server
+
+        if @aliases
+            if @aliases[:input]
+                @aliases[:input].each {|key, value|
+                    @server.dispatcher.alias(:input, key, value)
+                }
+            end
+
+            if @aliases[:output]
+                @aliases[:output].each {|key, value|
+                    @server.dispatcher.alias(:output, key, value)
+                }
+            end
+        end
+
+        if @events
+            if @events[:pre]
+                @server.dispatcher.register(:pre, nil, @events[:pre])
+            end
+
+            if @events[:post]
+                @server.dispatcher.register(:post, nil, @events[:post])
+            end
+
+            if @events[:default]
+                @server.dispatcher.register(:default, nil, @events[:default])
+            end
+            
+            if @events[:custom]
+                @events[:custom].each {|key, value|
+                    @server.dispatcher.register(:custom, key, value)
+                }
+            end
+
+            if @events[:input]
+                @events[:input].each {|key, value|
+                    @server.dispatcher.register(:input, key, value)
+                }
+            end
+
+            if @events[:output]
+                @events[:output].each {|key, value|
+                    @server.dispatcher.register(:output, key, value)
+                }
+            end
+        end
+
+        begin
+            rehash
+        rescue NameError
+        rescue Exception => e
+            self.debug e
+        end
+    end
+
+    def finalize
+        if @aliases
+            @aliases.each_key {|key|
+                @server.dispatcher.alias(key, nil)
+            }
+        end
+
+        if @events
+            @events.each_key {|key|
+                @server.dispatcher.register(key, nil)
+            }
+        end
+    end
+end
+
+end
+
+end