mad_chatter 0.2.9 → 0.3.0

data/lib/mad_chatter/server.rb

@@ -1,15 +1,9 @@
 module MadChatter
-  
   class Server
     
     def initialize(config)
       @config = config
       @server = initialize_server
-      @subscribers = {};
-    end
-    
-    def self.main_channel
-      @main_channel ||= EventMachine::Channel.new
     end
     
     def initialize_server
@@ -28,55 +22,6 @@ module MadChatter
       end
     end
     
-    def register_connection(&send_message)
-      subscriber_id = MadChatter::Server.main_channel.subscribe(send_message)
-      token = generate_token
-      send_message.call(MadChatter::Message.new('token', token).to_json)
-      @subscribers[subscriber_id] = token
-      MadChatter::MessageHistory.all.each do |json|
-        send_message.call(json)
-      end
-      subscriber_id
-    end
-    
-    def generate_token
-      Digest::SHA1.hexdigest(Time.now.to_s)
-    end
-    
-    def connection_closed(id)
-      token = @subscribers.delete(id)
-      username = MadChatter::Users.find_username_by_token(token)
-      MadChatter::Server.main_channel.unsubscribe(id)
-      MadChatter::Users.remove(token)
-      MadChatter::Server.send_json(MadChatter::Message.new('status', "#{username} has left the chatroom").to_json)
-      MadChatter::Server.send_json(MadChatter::Message.new('users', MadChatter::Users.current).to_json)
-    end
-    
-    def message_received(json)
-      msg = JSON.parse(json)
-      username = MadChatter::Users.find_username_by_token(msg['token'])
-      message = MadChatter::Message.new(msg['type'], msg['message'], msg['token'], username)
-      message.filter
-      
-      if message.token.nil?
-        return # Token is required to send messages
-      end
-      
-      begin
-        MadChatter.message_listeners.each do |listener|
-          listener.handle(message)
-        end
-        
-        MadChatter::Server.send_json(message.to_json)
-      rescue RuntimeError
-        # dont need to do anything, just prevent any errors from stopping the server
-      end
-    end
-
-    def self.send_json(json)
-      MadChatter::Server.main_channel.push(json)
-    end
-    
   end
 
 end

data/lib/mad_chatter/servers/em_websocket.rb

@@ -14,21 +14,12 @@ module MadChatter
       
       def start
         EventMachine::WebSocket.start(@config) do |ws|
-
           ws.onopen do
-            
-            connection_id = @main_server.register_connection do |msg|
-              ws.send(msg)
-            end
-            
-            ws.onclose do
-              @main_server.connection_closed(connection_id)
-            end
-
-            ws.onmessage do |msg|
-              @main_server.message_received(msg)
-            end
-
+            user = MadChatter::User.new
+            user.on_send { |msg| ws.send(msg) }
+            ws.onclose { user.disconnected }
+            ws.onmessage { |msg| MadChatter.message_received(msg) }
+            user.connected
           end
         end
       end

data/lib/mad_chatter/user.rb

@@ -0,0 +1,78 @@
+module MadChatter
+  class User
+    
+    attr_accessor :token, :username
+    
+    def initialize(token = nil, username = nil)
+      @token = token
+      @username = username
+    end
+    
+    def on_send(&blk)
+      @on_send = blk
+    end
+    
+    def send(json)
+      @on_send.call(json) if @on_send
+    end
+    
+    def connected
+      @token = generate_new_token unless @token
+      MadChatter.users << self
+      send_token
+      send_channels
+    end
+    
+    def generate_new_token
+      Digest::SHA1.hexdigest(Time.now.to_s)
+    end
+    
+    def send_token
+      send JSON.generate({
+        type: 'token',
+        text: @token,
+      })
+    end
+    
+    def send_channels
+      channels = MadChatter.channels.collect do |c|
+        {:id => c.id, :name => c.name }
+      end
+      send JSON.generate({
+        type: 'channels',
+        json: channels,
+      })
+    end
+    
+    def update_username(username)
+      old_username = @username
+      @username = username
+      send_users_list
+      MadChatter.channels.each do |channel|
+        channel.users.each do |user|
+          if user == self
+            channel.send_message MadChatter::Message.new('status', "#{old_username} is now known as #{@username}")
+          end
+        end
+      end
+    end
+    
+    def send_users_list
+      MadChatter.channels.each do |channel|
+        channel.users.each do |user|
+          channel.send_users_list if user == self
+        end
+      end
+    end
+    
+    def disconnected
+      MadChatter.channels.each do |channel|
+        channel.remove_user(self)
+      end
+    end
+    
+    def has_token?(token)
+      @token == token
+    end
+  end
+end

data/lib/mad_chatter/users.rb

@@ -1,31 +1,39 @@
 module MadChatter
   class Users
     
-    class << self
-      
-      def users
-        @users ||= {}
-      end
+    def initialize
+      @users = {}
+    end
+
+    def add(token, username = nil)
+      @users[token] = username
+    end
+        
+    def update(token, username)
+      @users[token] = username
+    end
+    
+    def remove(token)
+      @users.delete(token)
+    end
+    
+    def find_username_by_token(token)
+      @users[token]
+    end
+    
+    def current
+      @users.values
+    end
+    
+    def token_exists?(token)
+      @users[token].exists?
+    end
     
-      def update(token, username)
-        MadChatter::Users.users[token] = username
-      end
-      
-      def remove(token)
-        MadChatter::Users.users.delete(token)
-      end
-      
-      def find_username_by_token(token)
-        MadChatter::Users.users[token]
-      end
-      
-      def current
-        MadChatter::Users.users.values
-      end
-      
-      def token_exists?(token)
-        MadChatter::Users.users[token].exists?
-      end
+    def to_json
+      JSON.generate({
+        type: 'users',
+        json: current,
+      })
     end
     
   end

data/lib/mad_chatter/version.rb

@@ -1,5 +1,5 @@
 module MadChatter
   
-  VERSION = '0.2.9'
+  VERSION = '0.3.0'
 
 end

data/lib/mad_chatter.rb

@@ -2,47 +2,111 @@ lib_dir = File.expand_path('..', __FILE__)
 $:.unshift( lib_dir ) unless $:.include?( lib_dir )
 
 require 'eventmachine'
-require 'redcarpet'
 require 'yaml'
 require 'json'
 require 'digest/sha1'
 
+require 'mad_chatter/version'
+require 'mad_chatter/config'
+
+require 'mad_chatter/server'
+require 'mad_chatter/servers/em_websocket'
+
+require 'mad_chatter/channel'
+require 'mad_chatter/user'
+require 'mad_chatter/users'
+
+require 'mad_chatter/message'
+require 'mad_chatter/message_history'
+
+require 'mad_chatter/actions'
+require 'mad_chatter/message_listeners/join'
+require 'mad_chatter/message_listeners/markdown'
+require 'mad_chatter/message_listeners/nick'
+require 'mad_chatter/message_listeners/image'
+require 'mad_chatter/message_listeners/code'
+
+require 'mad_chatter/extensions'
+require 'mad_chatter/message_listener'
+
 module MadChatter
   
-  def self.message_listeners
-    @@message_listeners ||= []
-  end
-  
-  require 'mad_chatter/config'
-  require 'mad_chatter/message'
-  require 'mad_chatter/message_history'
-  require 'mad_chatter/markdown_renderer'
-  require 'mad_chatter/server'
-  require 'mad_chatter/users'
-  require 'mad_chatter/version'
-  require 'mad_chatter/actions/dsl'
-  require 'mad_chatter/actions/base'
-  require 'mad_chatter/actions/join'
-  require 'mad_chatter/actions/rename'
-
-  require 'mad_chatter/servers/em_websocket'
+  # attr_accessor :users, :channels, :message_listeners
   
-  def self.markdown
-    redcarpet_config = {
-      :autolink => true, 
-      :no_intra_emphasis => true
-    }
-    renderer_config = {
-      :filter_html => true, 
-      :hard_wrap => true
-    }
-    @markdown ||= Redcarpet::Markdown.new(MadChatter::MarkdownRenderer.new(renderer_config), redcarpet_config)
-  end
+  class << self
+    
+    def users
+      @users ||= []
+    end
+    
+    def users=(array)
+      @users = array
+    end
+    
+    def find_user_by_token(token)
+      users.each do |user|
+        return user if user.token == token
+      end
+    end
+    
+    def channels
+      @channels ||= []
+    end
+    
+    def channels=(array)
+      @channels = array
+    end
 
-  def self.start
-    config = MadChatter::Config.init
-    server = MadChatter::Server.new(config)
-    server.start
+    def find_channel_by_id(id)
+      channels.each do |channel|
+        return channel if channel.id == id
+      end
+    end
+        
+    def find_channel_by_name(name)
+      channels.each do |channel|
+        return channel if channel.name == name
+      end
+    end
+    
+    def message_listeners
+      @message_listeners ||= []
+    end
+    
+    def message_listeners=(array)
+      @message_listeners = array
+    end
+    
+    def start
+      config = MadChatter::Config.init
+      server = MadChatter::Server.new(config)
+      server.start
+    end
+    
+    def message_received(json)
+      msg = JSON.parse(json)
+      
+      if msg['token'].nil?
+        return # Token is required to send messages
+      end
+      
+      message = MadChatter::Message.new('message', msg['message'], msg['token'], msg['channel'])
+      
+      begin
+        message_listeners.each do |listener|
+          listener.handle(message)
+        end
+        send_message(message)
+      rescue RuntimeError
+        # dont need to do anything, just prevent any errors from stopping the server
+      end
+    end
+    
+    def send_message(message)
+      channels.each do |channel|
+        channel.send_message(message) if channel.id == message.channel
+      end
+    end
+    
   end
-  
 end

data/mad_chatter.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "thor"
   s.add_runtime_dependency "eventmachine"
   s.add_runtime_dependency "em-websocket"
-  s.add_runtime_dependency "redcarpet"
+  # s.add_runtime_dependency "redcarpet"
   s.add_runtime_dependency "daemons", "1.1.4"
 
   s.add_development_dependency "rspec"

data/spec/actions_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe MadChatter::Actions do
+  
+  # TODO
+  
+end

data/spec/message_history_spec.rb

@@ -2,28 +2,30 @@ require 'spec_helper'
 
 describe MadChatter::MessageHistory do
 
+  let (:history) { MadChatter::MessageHistory.new }
+  
   before(:each) do
-    MadChatter::MessageHistory.clear
+    
+    # MadChatter::MessageHistory.clear
   end
   
   it 'should only keep 10 recent messages' do
     15.times do
-      MadChatter::MessageHistory.add MadChatter::Message.new('message', 'Here is a dummy chat message')
+      history.add MadChatter::Message.new('message', 'Here is a dummy chat message')
     end
-    MadChatter::MessageHistory.all.length.should == 10
+    history.all.length.should == 10
   end
 
   it 'should allow you to clear the history' do
-    MadChatter::MessageHistory.add MadChatter::Message.new('message', 'Here is a dummy chat message')
-    MadChatter::MessageHistory.all.length.should == 1
-    MadChatter::MessageHistory.clear
-    MadChatter::MessageHistory.all.length.should == 0
+    history.add MadChatter::Message.new('message', 'Here is a dummy chat message')
+    history.all.length.should == 1
+    history.clear
+    history.all.length.should == 0
   end
   
   context '#all' do
-    it 'should still return an empty array if there is message chat history' do
-      history = MadChatter::MessageHistory.all
-      history.should == []
+    it 'should still return an empty array if there is no chat history' do
+      history.all.should == []
     end
   end
   

data/spec/message_listeners/code_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../spec_helper'
+
+describe MadChatter::MessageListeners::Code do
+
+  let (:server) { MadChatter::Server.new({'websocket_backend' => 'MadChatter::Servers::EventMachineWebSocket'}) }
+  let (:user) { MadChatter::User.new('usertoken') }
+  let (:channel) { MadChatter::Channel.new('myroom') }
+  let (:listener) { MadChatter::MessageListeners::Code.new }
+  
+  before(:each) do
+    MadChatter.users = []
+    MadChatter.channels = []
+  end
+  
+  it 'should set html correctly' do
+    MadChatter.users << user
+    MadChatter.channels << channel
+    begin
+      message_text = <<-EOS
+/code <?php
+    echo "multiline";
+    echo "code sample";
+?>
+EOS
+      message = MadChatter::Message.new('message', message_text, user.token, channel.id)
+      listener.handle(message)
+      message.html.should == <<-EOS
+<pre><?php
+    echo "multiline";
+    echo "code sample";
+?></pre>
+EOS
+    rescue RuntimeError
+    end
+  end
+  
+end

data/spec/message_listeners/join_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe MadChatter::MessageListeners::Join do
+
+  let (:server) { MadChatter::Server.new({'websocket_backend' => 'MadChatter::Servers::EventMachineWebSocket'}) }
+  let (:user) { MadChatter::User.new('usertoken') }
+  let (:channel) { MadChatter::Channel.new('myroom') }
+  let (:listener) { MadChatter::MessageListeners::Join.new }
+  
+  before(:each) do
+    MadChatter.users = []
+    MadChatter.channels = []
+  end
+  
+  it 'should add user to list of users in server and channel' do
+    MadChatter.users << user
+    MadChatter.channels << channel
+    begin
+      MadChatter.users.include?(user).should be_true
+      MadChatter.find_channel_by_name('myroom').users.include?(user).should be_false
+      message = MadChatter::Message.new('message', '/join', user.token, channel.id)
+      listener.handle(message)
+      MadChatter.find_channel_by_name('myroom').users.include?(user).should be_true
+    rescue RuntimeError
+    end
+  end
+  
+  it 'should parse messages correctly' do
+    message = MadChatter::Message.new('message', 'this /join should not count')
+    listener.handle(message)
+    # how to check that nothing happened?
+  end
+  
+end

data/spec/message_listeners/markdown_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../spec_helper'
+require 'mad_chatter/message_listeners/markdown'
+
+describe MadChatter::MessageListeners::Markdown do
+
+  let (:listener) { MadChatter::MessageListeners::Markdown.new }
+  
+  it 'should autolink urls with target="_blank"' do
+    message = MadChatter::Message.new('message', 'here is a link: http://example.com.')
+    listener.handle(message)
+    message.html.should == 'here is a link: <a target="_blank" href="http://example.com">http://example.com</a>.'
+  end
+  
+  it 'should autolink email addresses' do
+    message = MadChatter::Message.new('message', "feel free to email me at madchatter@example.com")
+    listener.handle(message)
+    message.html.should == 'feel free to email me at <a href="mailto:madchatter@example.com">madchatter@example.com</a>'
+  end
+  
+  it 'should parse italics' do
+    message = MadChatter::Message.new('message', "_this_ should have emphasis but this_one_should_not")
+    listener.handle(message)
+    message.html.should == '<em>this</em> should have emphasis but this_one_should_not'
+    
+    message = MadChatter::Message.new('message', "you can use *asterisks*")
+    listener.handle(message)
+    message.html.should == 'you can use <em>asterisks</em>'
+    
+    message = MadChatter::Message.new('message', "this _doesnt count either")
+    listener.handle(message)
+    message.html.should == 'this _doesnt count either'
+  end
+  
+  it 'should parse bold' do
+    message = MadChatter::Message.new('message', "here is a **strong** statement")
+    listener.handle(message)
+    message.html.should == 'here is a <strong>strong</strong> statement'
+  end
+  
+  # TODO
+  # it 'should interpret markdown style links' do
+  #   message = MadChatter::Message.new('message', "[link me up](http://www.example.com)")
+  #   listener.handle(message)
+  #   message.html.should == '<a target="_blank" href="http://www.example.com">link me up</a>'
+  # end
+  
+end

data/spec/message_spec.rb

@@ -1,37 +1,49 @@
 require 'spec_helper' # see http://stackoverflow.com/q/5061179/314318
 
 describe MadChatter::Message do
-  let (:message) { MadChatter::Message.new('joy', 'I am the model of the modern major general') }
 
+  before(:each) do
+    MadChatter.users = []
+    MadChatter.channels = []
+  end
+  
   it 'should have a well-known interface' do
+    message = MadChatter::Message.new('message', 'my chat message')
     [:text, :to_json, :filter].each do |m|
       message.should respond_to(m)
     end
   end
 
   it 'should encode into JSON correctly' do
-    message.to_json.should match /modern major general/
+    message = MadChatter::Message.new('type', 'message', 'token', 'channel')
+    message.to_json.should == 
+      '{"type":"type","text":"message","html":"message","username":null,"channel":"channel","growl":"message"}'
   end
-
-  context '#filter' do
-    it 'should remove <p> tags' do
-      message.filter.should_not match /<[\s\\]*p[\s]*>/
-    end
+  
+  context '#username' do
+    let (:user) { MadChatter::User.new('usertoken', 'myusername') }
+    let (:message) { MadChatter::Message.new('message', 'text', 'usertoken') }
     
-    it 'should be able to handle messages made of empty space' do
-      message = MadChatter::Message.new('message', "    ")
-      message.filter.should == ''
+    it 'should find username correctly' do
+      MadChatter.users << user
+      message.username.should == 'myusername'
     end
+  end
+  
+  context '#filter' do
+    
+    let (:message) { MadChatter::Message.new('message', 'text') }
     
-    it 'should add target="_blank" to links' do
-      message = MadChatter::Message.new('message', "[link me up](http://www.example.com)")
-      message.filter.should match %r{<a target="_blank" href="http://www.example.com">link me up</a>}
+    it 'should escape all html tags' do
+      html = "<strong>bold</strong><script>alert('text')</script>"
+      message.filter(html).should == "&lt;strong&gt;bold&lt;/strong&gt;&lt;script&gt;alert('text')&lt;/script&gt;"
     end
     
-    it 'should also add target="_blank" to links that were autolinked' do
-      message = MadChatter::Message.new('message', 'http://www.example.com')
-      message.filter.should match %r{<a target="_blank" href="http://www.example.com">http://www.example.com</a>}
+    it 'should be able to handle messages made of empty space' do
+      text = "    "
+      message.filter(text).should == ''
     end
+
   end
 
 end