hector 1.0.0

data/lib/hector/server.rb

@@ -0,0 +1,14 @@
+module Hector
+  class << self
+    attr_accessor :server_name
+
+    def start_server(address = "0.0.0.0", port = 6767, ssl_port = 6868)
+      EventMachine.start_server(address, port, Connection)
+      EventMachine.start_server(address, ssl_port, SSLConnection)
+      logger.info("Hector running on #{address}:#{port}")
+      logger.info("Secure Hector running on #{address}:#{ssl_port}")
+    end
+  end
+
+  self.server_name = "hector.irc"
+end

data/lib/hector/service.rb

@@ -0,0 +1,30 @@
+module Hector
+  class Service < Session
+    protected
+      def deliver_message_from_origin(text)
+        deliver_message_from_session(origin, text)
+      end
+
+      def deliver_message_from_service(text)
+        deliver_message_from_session(self, text)
+      end
+
+      def deliver_message_from_session(session, text)
+        command, destination = response.command, find(response.args.first)
+        Hector.defer do
+          destination.deliver(command, session, :source => session.source, :text => text)
+        end
+      end
+
+      def intercept(pattern)
+        if response.text =~ pattern
+          yield *$~
+          throw :stop
+        end
+      end
+
+      def origin
+        find(response.source[/^([^!]+)!/, 1])
+      end
+  end
+end

data/lib/hector/session.rb

@@ -0,0 +1,185 @@
+module Hector
+  class Session
+    include Concerns::KeepAlive
+    include Concerns::Presence
+
+    include Commands::Join
+    include Commands::Mode
+    include Commands::Names
+    include Commands::Nick
+    include Commands::Notice
+    include Commands::Part
+    include Commands::Ping
+    include Commands::Pong
+    include Commands::Privmsg
+    include Commands::Quit
+    include Commands::Realname
+    include Commands::Topic
+    include Commands::Who
+    include Commands::Whois
+    include Commands::Away
+
+    attr_reader :nickname, :request, :response, :away_message
+
+    SESSIONS = {}
+
+    class << self
+      def all
+        sessions.values.grep(self)
+      end
+
+      def nicknames
+        sessions.keys
+      end
+
+      def find(nickname)
+        sessions[normalize(nickname)]
+      end
+
+      def rename(from, to)
+        if find(to)
+          raise NicknameInUse, to
+        else
+          find(from).tap do |session|
+            delete(from)
+            sessions[normalize(to)] = session
+          end
+        end
+      end
+
+      def delete(nickname)
+        sessions.delete(normalize(nickname))
+      end
+
+      def broadcast_to(sessions, command, *args)
+        except = args.last.delete(:except) if args.last.is_a?(Hash)
+        sessions.each do |session|
+          session.respond_with(command, *args) unless session == except
+        end
+      end
+
+      def normalize(nickname)
+        if nickname =~ /^\w[\w-]{0,15}$/u
+          nickname.downcase
+        else
+          raise ErroneousNickname, nickname
+        end
+      end
+
+      def register(session)
+        sessions[normalize(session.nickname)] = session
+        session
+      end
+
+      def reset!
+        sessions.clear
+      end
+
+      protected
+        def sessions
+          SESSIONS
+        end
+    end
+
+    def initialize(nickname)
+      @nickname = nickname
+    end
+
+    def broadcast(command, *args)
+      Session.broadcast_to(peer_sessions, command, *args)
+    end
+
+    def channel?
+      false
+    end
+
+    def deliver(message_type, session, options)
+      respond_with(message_type, nickname, options)
+    end
+
+    def destroy
+      self.class.delete(nickname)
+    end
+
+    def find(name)
+      destination_klass_for(name).find(name).tap do |destination|
+        raise NoSuchNickOrChannel, name unless destination
+      end
+    end
+
+    def hostname
+      Hector.server_name
+    end
+
+    def name
+      nickname
+    end
+
+    def realname
+      nickname
+    end
+
+    def receive(request)
+      @request = request
+      if respond_to?(@request.event_name)
+        send(@request.event_name)
+      end
+    ensure
+      @request = nil
+    end
+
+    def rename(new_nickname)
+      Session.rename(nickname, new_nickname)
+      @nickname = new_nickname
+    end
+
+    def respond_with(command, *args)
+      @response = command.is_a?(Response) ? command : Response.new(command, *preprocess_args(args))
+      if respond_to?(@response.event_name)
+        send(@response.event_name)
+      end
+      @response
+    ensure
+      @response = nil
+    end
+
+    def away(away_message)
+      @away_message = away_message
+    end
+
+    def away?
+      !@away_message.nil?
+    end
+
+    def back
+      @away_message = nil
+    end
+
+    def source
+      "#{nickname}!#{username}@#{hostname}"
+    end
+
+    def username
+      "~#{nickname}"
+    end
+
+    def who
+      "#{identity.username} #{Hector.server_name} #{Hector.server_name} #{nickname} H :0 #{realname}"
+    end
+
+    protected
+      def destination_klass_for(name)
+        name =~ /^#/ ? Channel : Session
+      end
+
+      def preprocess_args(args)
+        args.map do |arg|
+          if arg.is_a?(Symbol) && arg.to_s[0, 1] == "$"
+            send(arg.to_s[1..-1])
+          else
+            arg
+          end
+        end
+      end
+  end
+end

data/lib/hector/user_session.rb

@@ -0,0 +1,38 @@
+module Hector
+  class UserSession < Session
+    attr_reader :connection, :identity, :realname
+
+    class << self
+      def create(nickname, connection, identity, realname)
+        if find(nickname)
+          raise NicknameInUse, nickname
+        else
+          register UserSession.new(nickname, connection, identity, realname)
+        end
+      end
+    end
+
+    def initialize(nickname, connection, identity, realname)
+      super(nickname)
+      @connection = connection
+      @identity   = identity
+      @realname   = realname
+      initialize_keep_alive
+      initialize_presence
+    end
+
+    def destroy
+      super
+      destroy_presence
+      destroy_keep_alive
+    end
+
+    def respond_with(*)
+      connection.respond_with(super)
+    end
+
+    def username
+      identity.username
+    end
+  end
+end

data/lib/hector/version.rb

@@ -0,0 +1,3 @@
+module Hector
+  VERSION = "1.0.0"
+end

data/lib/hector/yaml_identity_adapter.rb

@@ -0,0 +1,56 @@
+module Hector
+  # Identity adapters must implement the following public methods:
+  #  - authenticate(username, password)
+  #  - remember(username, password)
+  #  - forget(username)
+  #  - normalize(username)
+  #
+  class YamlIdentityAdapter
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = File.expand_path(filename)
+    end
+
+    def authenticate(username, password)
+      yield load_identities[normalize(username)] == hash(normalize(username), password)
+    end
+
+    def remember(username, password)
+      identities = load_identities
+      identities[normalize(username)] = hash(normalize(username), password)
+      store_identities(identities)
+    end
+
+    def forget(username)
+      identities = load_identities
+      identities.delete(normalize(username))
+      store_identities(identities)
+    end
+
+    def normalize(username)
+      username.strip.downcase
+    end
+
+    protected
+      def load_identities
+        ensure_file_exists
+        YAML.load_file(filename) || {}
+      end
+
+      def store_identities(identities)
+        File.open(filename, "w") do |file|
+          file.puts(identities.to_yaml)
+        end
+      end
+
+      def hash(username, password)
+        Digest::SHA1.hexdigest(Digest::SHA1.hexdigest(username) + password)
+      end
+
+      def ensure_file_exists
+        FileUtils.mkdir_p(File.dirname(filename))
+        FileUtils.touch(filename)
+      end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: hector
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Sam Stephenson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-04 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id002
+description: A private group chat server for people you trust. Implements a limited subset of the IRC protocol.
+email: 
+- sstephenson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/hector/boot.rb
+- lib/hector/channel.rb
+- lib/hector/commands/away.rb
+- lib/hector/commands/join.rb
+- lib/hector/commands/mode.rb
+- lib/hector/commands/names.rb
+- lib/hector/commands/nick.rb
+- lib/hector/commands/notice.rb
+- lib/hector/commands/part.rb
+- lib/hector/commands/ping.rb
+- lib/hector/commands/pong.rb
+- lib/hector/commands/privmsg.rb
+- lib/hector/commands/quit.rb
+- lib/hector/commands/realname.rb
+- lib/hector/commands/topic.rb
+- lib/hector/commands/who.rb
+- lib/hector/commands/whois.rb
+- lib/hector/concerns/authentication.rb
+- lib/hector/concerns/keep_alive.rb
+- lib/hector/concerns/presence.rb
+- lib/hector/connection.rb
+- lib/hector/deference.rb
+- lib/hector/errors.rb
+- lib/hector/heartbeat.rb
+- lib/hector/identity.rb
+- lib/hector/logging.rb
+- lib/hector/request.rb
+- lib/hector/response.rb
+- lib/hector/server.rb
+- lib/hector/service.rb
+- lib/hector/session.rb
+- lib/hector/user_session.rb
+- lib/hector/version.rb
+- lib/hector/yaml_identity_adapter.rb
+- lib/hector.rb
+has_rdoc: true
+homepage: http://github.com/sstephenson/hector
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Private group chat server
+test_files: []
+