rlyeh 0.0.1 → 0.0.2

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+vendor

data/examples/echo.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift 'lib', '../lib'
+require 'rlyeh'
+
+class Echo < Rlyeh::Base
+  def call(env)
+    conn = env.connection
+    conn.send_data env.message
+  end
+end
+
+Rlyeh.emerge Echo

data/{example → examples}/middleware.rb

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-$LOAD_PATH.unshift 'lib'
+$LOAD_PATH.unshift 'lib', '../lib'
 require 'rlyeh'
+require 'logger'
 
 class MyMiddleware
   include Rlyeh::Dispatcher
@@ -21,6 +22,7 @@ class MyMiddleware
 end
 
 class MyApp < Rlyeh::Base
+  use Rlyeh::DeepOnes::Logger, :level => Logger::DEBUG
   use MyMiddleware
 
   on :privmsg do |env|

data/examples/simple.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift 'lib', '../lib'
+require 'rlyeh'
+
+class MyApp < Rlyeh::Base
+  use Rlyeh::DeepOnes::Logger, :level => 0
+  use Rlyeh::DeepOnes::Auth do |auth|
+    auth.nick if [auth.nick, auth.pass] == ['dankogai', 'kogaidan']
+  end
+  
+  set :server_name, 'MyApp'
+  set :server_version, '1.0.0'
+
+  on :privmsg do |env|
+    puts "RECV: #{env.message}"
+  end
+end
+
+Rlyeh.emerge MyApp, :host => '0.0.0.0'

data/lib/rlyeh/base.rb

@@ -1,9 +1,15 @@
 require 'rlyeh/dispatcher'
-require 'rlyeh/middleware/builder'
+require 'rlyeh/settings'
+require 'rlyeh/deep_ones/builder'
+require 'rlyeh/deep_ones/parser'
 
 module Rlyeh
   class Base
     include Rlyeh::Dispatcher
+    include Rlyeh::Settings
+
+    set :server_name, 'Rlyeh'
+    set :server_version, Rlyeh::VERSION
 
     class << self
       def middlewares
@@ -23,11 +29,9 @@ module Rlyeh
 
       alias new! new unless method_defined? :new!
       def new(*args, &block)
-        build(Rlyeh::Middleware::Builder.new, *args, &block).to_app
+        build(Rlyeh::DeepOnes::Builder.new, *args, &block).to_app
       end
 
-      private
-
       def build(builder, *args, &block)
         setup_default_middlewares builder
         setup_middlewares builder
@@ -36,6 +40,8 @@ module Rlyeh
       end
 
       def setup_default_middlewares(builder)
+        builder.use! Rlyeh::DeepOnes::Closer
+        builder.use! Rlyeh::DeepOnes::Parser
       end
 
       def setup_middlewares(builder)
@@ -45,23 +51,20 @@ module Rlyeh
       end
     end
 
-    def initialize(app = nil)
+    def initialize(app = nil, options = {})
       @app = app
+      @options = options
       yield self if block_given?
     end
 
     def call(env)
       name = env.message.command.to_s.downcase
       trigger name, env
-
       @app.call env if @app
     end
 
-    def trigger(name, *args, &block)
-      callbacks = self.class.callbacks name
-      callbacks.each do |callback|
-        callback.bind(self).call *args, &block
-      end
+    def halt
+      throw :halt
     end
   end
 end

data/lib/rlyeh/connection.rb

@@ -1,23 +1,24 @@
-require 'ircp'
 require 'rlyeh/environment'
+require 'rlyeh/filters'
+require 'rlyeh/sendable'
 
 module Rlyeh
   class Connection < EventMachine::Connection
     include EventMachine::Protocols::LineText2
+    include Rlyeh::Sendable
 
-    attr_reader :server, :klass, :options
+    attr_reader :server, :app_class, :options
     attr_reader :app, :session
 
-    def initialize(server, klass, options)
+    def initialize(server, app_class, options)
       @server = server
-      @klass = klass
+      @app_class = app_class
       @options = options
       set_delimiter "\r\n"
     end
 
     def post_init
-      @app = klass.new
-      #@app = @app_class.new self, options
+      @app = app_class.new nil, @options
     end
 
     def unbind
@@ -26,30 +27,29 @@ module Rlyeh
 
     def receive_line(data)
       env = Rlyeh::Environment.new
+      env.data = data
+      env.server = @server
       env.connection = self
-      env.raw = data
+      env.settings = @app_class.settings
 
-      begin
-        env.message = Ircp.parse data
-      rescue Ircp::ParseError => e
-        p e
-      else
+      catch :halt do
         @app.call env
       end
     end
 
     def attached(session)
       @session = session
-      #@app.attached session
     end
 
-    def deatched(session)
-      #@app.detached session
+    def detached(session)
       @session = nil
     end
 
     def attached?
       !!@session
     end
+
+    include Rlyeh::Filters
+    define_filters :attached, :detached
   end
 end

data/lib/rlyeh/deep_ones/auth.rb

@@ -0,0 +1,72 @@
+require 'socket'
+require 'rlyeh/dispatcher'
+
+module Rlyeh
+  module DeepOnes
+    class Auth
+      include Rlyeh::Dispatcher
+
+      attr_reader :nick, :pass, :user, :real, :host
+
+      def initialize(app, &authenticator)
+        @app = app
+        @authenticator = authenticator
+        @authorized = false
+      end
+
+      def call(env)
+        dispatch env
+
+        if authorized?
+          env.auth = self
+          @app.call env
+        end
+      end
+
+      def load_session(env, id)
+        env.server.sessions[id] ||= Rlyeh::Session.new(id)
+      end
+
+      def authorized?
+        @authorized
+      end
+
+      def authorized(env)
+        name = env.settings.server_name
+        version = env.settings.server_version
+        
+        env.connection.tap do |conn|
+          conn.send_numeric_reply :welcome, @host, "Welcome to the Internet Relay Network #{@nick}!#{@user}@#{@host}"
+          conn.send_numeric_reply :yourhost, @host, "Your host is #{name}, running version #{version}"
+          conn.send_numeric_reply :created,  @host, "This server was created #{Time.now}"
+          conn.send_numeric_reply :myinfo, @host, "#{name} #{version} #{""} #{""}"
+        end
+      end
+
+      on :pass do |env|
+        @pass = env.message.params[0]
+      end
+
+      on :nick do |env|
+        @nick = env.message.params[0]
+      end
+
+      on :user do |env|
+        @user = env.message.params[0]
+        @real = env.message.params[3]
+        port, @host = Socket.unpack_sockaddr_in(env.connection.get_peername)
+
+        session_id = @authenticator.call(self)
+        if session_id.nil?
+          p "Auth error"
+        else
+          @authorized = true
+          session = load_session env, session_id
+          session.attach env.connection
+          authorized env
+          p 'Session attached.'
+        end
+      end
+    end
+  end
+end

data/lib/rlyeh/deep_ones/builder.rb

@@ -0,0 +1,37 @@
+module Rlyeh
+  module DeepOnes
+    class Builder
+      def initialize(app = nil, &block)
+        @stack = []
+        @runner = app
+        instance_eval(&block) if block_given?
+      end
+
+      def self.app(app = nil, &block)
+        self.new(app, &block).to_app
+      end
+
+      def use(middleware, *args, &block)
+        @stack << proc { |app| middleware.new(app, *args, &block) }
+      end
+
+      def use!(middleware, *args, &block)
+        @stack.unshift lambda { |app| middleware.new(app, *args, &block) }
+      end
+
+      def run(app)
+        @runner = app
+      end
+
+      def to_app
+        @stack.reverse.inject(@runner) do |inner, outer|
+          outer.call inner
+        end
+      end
+
+      def call(env)
+        to_app.call(env)
+      end
+    end
+  end
+end

data/lib/rlyeh/deep_ones/closer.rb

@@ -0,0 +1,18 @@
+require 'rlyeh/dispatcher'
+
+module Rlyeh
+  module DeepOnes
+    class Closer
+      include Rlyeh::Dispatcher
+      
+      def initialize(app)
+        @app = app
+      end
+
+      on :quit do |env|
+        env.connection.close_connection_after_writing
+        throw :halt
+      end
+    end
+  end
+end

data/lib/rlyeh/deep_ones/logger.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+module Rlyeh
+  module DeepOnes
+    class Logger
+      def initialize(app, options = {})
+        @app = app
+        @logger = options[:logger] || ::Logger.new(STDOUT)
+        @logger.level = options[:level] || ::Logger::INFO
+      end
+
+      def call(env)
+        write env
+        @app.call env
+      end
+
+      def write(env)
+        @logger.debug env.data
+      end
+    end
+  end
+end

data/lib/rlyeh/deep_ones/parser.rb

@@ -0,0 +1,21 @@
+require 'ircp'
+
+module Rlyeh
+  module DeepOnes
+    class Parser
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        begin
+          message = Ircp.parse env.data
+          env.message = message
+          @app.call env
+        rescue Ircp::ParseError => e
+          p e
+        end
+      end
+    end
+  end
+end

data/lib/rlyeh/{middleware → deep_ones}/typablemap.rb

@@ -1,5 +1,5 @@
 module Rlyeh
-  module Middleware
+  module DeepOnes
     class TypableMap
       def initialize(app)
         @app = app

data/lib/rlyeh/deep_ones.rb

@@ -0,0 +1,9 @@
+module Rlyeh
+  module DeepOnes
+    autoload :Parser,  'rlyeh/deep_ones/parser'
+    autoload :Builder, 'rlyeh/deep_ones/builder'
+    autoload :Closer,  'rlyeh/deep_ones/closer'
+    autoload :Logger,  'rlyeh/deep_ones/logger'
+    autoload :Auth,    'rlyeh/deep_ones/auth'
+  end
+end

data/lib/rlyeh/dispatcher.rb

@@ -1,3 +1,5 @@
+require 'rlyeh/utils'
+
 module Rlyeh
   module Dispatcher
     def self.included(base)
@@ -7,7 +9,15 @@ module Rlyeh
     module ClassMethods
       def callbacks(name)
         @dispatchers ||= {}
-        callbacks = @dispatchers[name] || []
+
+        callbacks = @dispatchers.select do |key, value|
+          if key.is_a?(Regexp)
+            key =~ name
+          else
+            key == name
+          end
+        end.values.flatten
+
         if superclass.respond_to?(:callbacks)
           superclass.callbacks(name) + callbacks
         else
@@ -17,18 +27,16 @@ module Rlyeh
 
       def on(name, &block)
         @dispatchers ||= {}
-        name = name.to_s
+        name = name.to_s if name.is_a?(Symbol)
         callbacks = (@dispatchers[name] ||= [])
-        callbacks << generate_method(name, &block)
+        callbacks << Rlyeh::Utils.generate_method(self, "__on_#{name}", block)
         callbacks.uniq!
       end
+    end
 
-      def generate_method(method_name, &block)
-        define_method method_name, &block
-        method = instance_method method_name
-        remove_method method_name
-        method
-      end
+    def call(env)
+      dispatch env
+      @app.call env if @app
     end
 
     def dispatch(env)
@@ -39,7 +47,7 @@ module Rlyeh
     def trigger(name, *args, &block)
       callbacks = self.class.callbacks name
       callbacks.each do |callback|
-        callback.bind(self).call *args, &block
+        break if callback.bind(self).call(*args, &block) == false
       end
     end
   end

data/lib/rlyeh/environment.rb

@@ -1,18 +1,21 @@
 module Rlyeh
   class Environment < ::Hash
-    def method_missing(method_id, *args)
-      case method_id.to_s
-      when /^(.+)=$/
-        store $1.to_sym, args.first
-      when /^(.+)\?$/
-        key? $1.to_sym
-      else
-        unless key? method_id
-          store method_id, Environment.new
-        else
-          fetch method_id
-        end
-      end
+    def respond_to?(method_id, include_private = false)
+      super || respond_to_missing?(method_id, include_private)
+    end
+
+    def respond_to_missing?(method_name, include_private)
+      method_name = method_id.to_s
+      return true if method_name =~ /^(.+)=$/
+      return true if self.key? method_name
+      super
+    end
+
+    def method_missing(method_id, *args, &block)
+      method_name = method_id.to_s
+      return self[$1] = args.first if method_name =~ /^(.+)=$/
+      return self[method_name] if self.key? method_name
+      super method_id, *args, &block
     end
   end
 end

data/lib/rlyeh/filters.rb

@@ -0,0 +1,91 @@
+require 'rlyeh/utils'
+
+module Rlyeh
+  module Filters
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_filters(*names, &block)
+        names.each do |name|
+          unless method_defined?("#{name}_with_filters")
+            define_method(:"#{name}_with_filters") do |*args, &block|
+              run_filters name, *args do
+                send(:"#{name}_without_filters", *args, &block)
+              end
+            end
+            alias_method :"#{name}_without_filters", :"#{name}"
+            alias_method :"#{name}", :"#{name}_with_filters"
+          end
+        end
+      end
+    end
+
+    def run_filters(name, *args, &block)
+      catch :halt do
+        _run_filters name, [:before, :arround], *args
+        result = block.call *args if block
+        _run_filters name, [:arround, :after], *args
+        result
+      end
+    end
+
+    [:before, :after, :around].each do |type|
+      define_method(:"#{type}_filter") do |*names, &block|
+        _insert_filter(names, type, block)
+      end
+      alias_method :"append_#{type}_filter", :"#{type}_filter"
+
+      define_method(:"prepend_#{type}_filter") do |*names, &block|
+        _insert_filter(names, type, block, :prepend => true)
+      end
+
+      define_method(:"remove_#{type}_filter") do |*names, &block|
+        _remove_filter(names, type, block)
+      end
+    end
+
+    private
+
+    def _filters
+      @_filters ||= {}
+    end
+
+    def _run_filters(name, types, *args, &block)
+      named_filters = _filters[name.to_s] || {}
+      types.each do |type|
+        (named_filters[type.to_s] || []).each do |filter|
+          throw :halt if filter.bind(self).call(*args, &block) == false
+        end
+      end
+    end
+
+    def _generate_filter_method(name, type, block)
+      method_name = "__filter_#{type}_#{name}"
+      Rlyeh::Utils.generate_method(Rlyeh::Utils.singleton_class(self), method_name, block)
+    end
+
+    def _insert_filter(names, type, block, options = {})
+      prepend = options[:prepend]
+      names.each do |name|
+        filter = _generate_filter_method name, type, block
+        named_filters = (_filters[name.to_s] ||= {})
+        filters = (named_filters[type.to_s] ||= [])
+        if prepend
+          filters.unshift filter
+        else
+          filters.push filter
+        end
+      end
+    end
+
+    def _remove_filter(names, type, block)
+      names.each do |name|
+        named_filters = (_filters[name.to_s] ||= {})
+        filters = (named_filters[type.to_s] ||= [])
+        filters.delete block
+      end
+    end
+  end
+end