flamethrower 0.0.1

data/lib/flamethrower/campfire/room.rb

@@ -0,0 +1,142 @@
+module Flamethrower
+  module Campfire
+    class Room
+      include Flamethrower::Campfire::RestApi
+
+      attr_reader :stream, :token
+      attr_writer :topic
+      attr_accessor :inbound_messages, :outbound_messages, :thread_messages, :number, :name, :users, :server
+      attr_accessor :failed_messages
+
+      def initialize(domain, token, params = {})
+        @domain = domain
+        @token = token
+        @inbound_messages = Queue.new
+        @outbound_messages = Queue.new
+        @failed_messages = []
+        @number = params['id']
+        @name = params['name']
+        @topic = params['topic']
+        @users = []
+        @thread_running = false
+      end
+
+      def topic
+        @topic || "No topic"
+      end
+
+      def send_topic!(topic)
+        response = campfire_put("/room/#{@number}.json", {:topic => topic}.to_json)
+        @topic = topic if response.code == "200"
+      end
+
+      def fetch_room_info
+        response = campfire_get("/room/#{@number}.json")
+        json = JSON.parse(response.body)
+        json['room']['users'].each do |user|
+          @users << Flamethrower::Campfire::User.new(user)
+        end
+      end
+
+      def say(body, message_type='TextMessage')
+        params = {'body' => body, 'type' => message_type}
+        @outbound_messages << Flamethrower::Campfire::Message.new(params)
+      end
+
+      def start_thread
+        ::FLAMETHROWER_LOGGER.debug "Starting thread for room #{name}"
+        @thread_running = true
+        Thread.new do
+          connect
+          until dead?
+            fetch_messages
+            post_messages
+            requeue_failed_messages
+            messages_to_send = to_irc.retrieve_irc_messages
+            messages_to_send.each do |m| 
+              ::FLAMETHROWER_LOGGER.debug "Sending irc message #{m.to_s}"
+              @server.send_message(m.to_s)
+            end
+            sleep 0.5
+          end
+        end
+      end
+
+      def alive?
+        @thread_running
+      end
+
+      def dead?
+        !@thread_running
+      end
+
+      def kill_thread!
+        @thread_running = false
+      end
+
+      def join
+        campfire_post("/room/#{@number}/join.json").code == "200"
+      end
+
+      def connect
+        ::FLAMETHROWER_LOGGER.debug "Connecting to #{name} stream"
+        @stream = Twitter::JSONStream.connect(:path => "/room/#{@number}/live.json", 
+                                    :host => "streaming.campfirenow.com", 
+                                    :auth => "#{@token}:x")
+      end
+
+      def fetch_messages
+        @stream.each_item do |item| 
+          params = JSON.parse(item)
+          ::FLAMETHROWER_LOGGER.debug "Got json message #{params.inspect}"
+          params['user'] = @users.find {|u| u.number == params['user_id'] }
+          params['room'] = self
+          @inbound_messages << Flamethrower::Campfire::Message.new(params)
+        end
+      end
+
+      def post_messages
+        until @outbound_messages.empty?
+          message = @outbound_messages.pop
+          json = {"message" => {"body" => message.body, "type" => message.message_type}}.to_json
+          ::FLAMETHROWER_LOGGER.debug "Sending #{json} to campfire API"
+          response = campfire_post("/room/#{@number}/speak.json", json)
+          case response
+          when Net::HTTPCreated
+            message.mark_delivered!
+          else
+            ::FLAMETHROWER_LOGGER.debug "Failed to post to campfire API with code: #{response.inspect}"
+            message.mark_failed!
+            @failed_messages << message
+          end
+        end
+      end
+
+      def retrieve_messages
+        Array.new.tap do |new_array|
+          until @inbound_messages.empty?
+            new_array << @inbound_messages.pop
+          end
+        end
+      end
+
+      def requeue_failed_messages
+        @failed_messages.each do |m| 
+          if m.retry_at > Time.now
+            @outbound_messages << m 
+            @failed_messages.delete(m)
+          end
+        end
+      end
+
+      def to_irc
+        name = "##{@name.downcase.scan(/[A-Za-z0-9]+/).join("_")}"
+        @irc_channel = Flamethrower::Irc::Channel.new(name, self)
+        @irc_channel.tap do |channel|
+          channel.users = @users.map(&:to_irc)
+          channel.topic = topic.gsub("\n", "\s")
+        end
+      end
+    end
+  end
+end

data/lib/flamethrower/campfire/user.rb

@@ -0,0 +1,17 @@
+module Flamethrower
+  module Campfire
+    class User
+      attr_accessor :name, :number
+
+      def initialize(params = {})
+        @name = params['name']
+        @number = params['id']
+      end
+
+      def to_irc
+        nick = @name.gsub("\s", "_")
+        @irc_user ||= Flamethrower::Irc::User.new(:username => nick, :nickname => nick, :hostname => 'campfirenow.com')
+      end
+    end
+  end
+end

data/lib/flamethrower/dispatcher.rb

@@ -0,0 +1,102 @@
+module Flamethrower
+  class Dispatcher
+    attr_reader :server
+
+    def initialize(server)
+      @server = server
+    end
+    
+    def handle_message(message)
+      method = "handle_#{message.command.downcase}"
+      send(method, message) if protected_methods.include?(method)
+    end
+
+    private
+
+    def find_channel_or_error(name, error=Flamethrower::Irc::Codes::ERR_BADCHANNELKEY)
+      channel = server.irc_channels.detect {|channel| channel.name == name}
+      if channel && block_given?
+        yield(channel)
+      else
+        server.send_message(server.error(error))
+      end
+    end
+
+    protected
+
+    def handle_privmsg(message)
+      name, body = *message.parameters
+      find_channel_or_error(name) do |channel|
+        channel.to_campfire.say(body)
+      end
+    end
+
+    def handle_ping(message)
+      hostname = *message.parameters
+      server.send_pong(hostname)
+    end
+
+    def handle_user(message)
+      username, hostname, servername, realname = *message.parameters
+      server.current_user.username = username unless server.current_user.username
+      server.current_user.hostname = hostname unless server.current_user.hostname
+      server.current_user.servername = servername unless server.current_user.servername
+      server.current_user.realname = realname unless server.current_user.realname
+      if server.current_user.nick_set? && server.current_user.user_set?
+        server.after_connect
+      end
+    end
+
+    def handle_nick(message)
+      nickname = *message.parameters
+      server.current_user.nickname = nickname
+      if server.current_user.nick_set? && server.current_user.user_set?
+        server.after_connect
+      end
+    end
+
+    def handle_topic(message)
+      find_channel_or_error(message.parameters.first) do |channel|
+        channel.to_campfire.send_topic!(message.parameters.last) if message.parameters.size > 1
+        server.send_topic(channel)
+      end
+    end
+
+    def handle_mode(message)
+      first_param = message.parameters.first
+      error = Flamethrower::Irc::Codes::ERR_UNKNOWNCOMMAND
+      if first_param == server.current_user.nickname
+        server.send_user_mode
+        return
+      else
+        find_channel_or_error(first_param, error) do |channel|
+          server.send_channel_mode(channel)
+        end
+      end
+    end
+
+    def handle_join(message)
+      find_channel_or_error(message.parameters.first) do |channel|
+        room = channel.to_campfire
+        channel.users << server.current_user
+        room.join
+        room.fetch_room_info
+        room.start_thread
+        server.send_topic(channel)
+        server.send_userlist(channel)
+      end
+    end
+
+    def handle_part(message)
+      find_channel_or_error(message.parameters.first) do |channel|
+        room = channel.to_campfire
+        room.kill_thread!
+      end
+    end
+
+    def handle_quit(message)
+      server.irc_channels.each {|c| c.to_campfire.kill_thread!}
+    end
+  end
+end
+

data/lib/flamethrower/irc/channel.rb

@@ -0,0 +1,55 @@
+module Flamethrower
+  module Irc
+    class Channel
+
+      attr_accessor :name, :modes, :mode
+
+      def initialize(name, campfire_channel=nil)
+        @users = []
+        @name = name
+        @modes = ["t"]
+        @campfire_channel = campfire_channel
+      end
+
+      def mode
+        "+#{@modes.join}"
+      end
+
+      def topic
+        campfire_topic = to_campfire.topic
+        return "No topic" if campfire_topic && campfire_topic.empty?
+        campfire_topic
+      end
+
+      def topic=(topic)
+        to_campfire.topic = topic 
+      end
+
+      def to_campfire
+        @campfire_channel
+      end
+
+      def users=(users)
+        @users = users
+      end
+
+      def users
+        @users.concat(@campfire_channel.users.map(&:to_irc))
+      end
+
+      def retrieve_irc_messages
+        to_campfire.retrieve_messages.inject([]) do |all_messages, message|
+          all_messages << message.to_irc if display_message?(message)
+          all_messages
+        end
+      end
+
+      private
+
+      def display_message?(message)
+        message.message_type != "TimestampMessage"
+      end
+
+    end
+  end
+end

data/lib/flamethrower/irc/codes.rb

@@ -0,0 +1,17 @@
+module Flamethrower
+  module Irc
+    module Codes
+      RPL_MOTDSTART = 375
+      RPL_MOTD = 372
+      RPL_ENDOFMOTD = 376
+      RPL_TOPIC = 332
+      RPL_NAMEREPLY = 353
+      RPL_ENDOFNAMES = 366
+      RPL_CHANNELMODEIS = 324
+      RPL_UMODEIS = 221
+
+      ERR_UNKNOWNCOMMAND = 421
+      ERR_BADCHANNELKEY = 475
+    end
+  end
+end

data/lib/flamethrower/irc/commands.rb

@@ -0,0 +1,57 @@
+module Flamethrower
+  module Irc
+    module Commands
+      include Flamethrower::Irc::Codes
+
+      def send_motd
+        send_messages do |messages|
+          messages << reply(RPL_MOTDSTART, ":MOTD")
+          messages << reply(RPL_MOTD, ":Welcome to Flamethrower")
+          messages << reply(RPL_MOTD, ":Fetching channel list from campfire...")
+        end
+      end
+
+      def send_topic(channel)
+        send_message reply(RPL_TOPIC, "#{channel.name} :#{channel.topic}")
+      end
+
+      def send_channel_list
+        send_messages do |messages|
+          messages << reply(RPL_MOTD, ":Active channels:")
+          @irc_channels.each do |channel|
+            messages << reply(RPL_MOTD, ":#{channel.name} - #{channel.topic}")
+          end
+          messages << reply(RPL_ENDOFMOTD, ":End of channel list /MOTD")
+        end
+      end
+
+      def send_userlist(channel)
+        send_messages do |messages|
+          display_users = (["@#{@current_user.nickname}"] + channel.users.map(&:nickname)).join("\s")
+          messages << reply(RPL_NAMEREPLY, "= #{channel.name} :#{display_users}")
+          messages << reply(RPL_ENDOFNAMES, "#{channel.name} :/End of /NAMES list")
+        end
+      end
+
+      def send_channel_mode(channel)
+        send_message reply(RPL_CHANNELMODEIS, "#{channel.name} #{channel.mode}")
+      end
+
+      def send_pong(hostname)
+        send_message "PONG :#{hostname}"
+      end
+
+      def send_user_mode
+        send_message reply(RPL_UMODEIS, @current_user.mode)
+      end
+
+      def reply(code, message)
+        ":#{@current_user.hostname} #{code} #{@current_user.nickname} #{message}"
+      end
+
+      def error(code)
+        ":#{@current_user.hostname} #{code}"
+      end
+    end
+  end
+end

data/lib/flamethrower/irc/message.rb

@@ -0,0 +1,41 @@
+module Flamethrower
+  module Irc
+    class Message
+      def initialize(message)
+        @message = message
+      end
+
+      def parse
+        terms = @message.split("\s")
+        params = terms - [terms.first]
+        {:command => terms.first, :params => strip_prefixes(params)}
+      end
+
+      def command
+        parse[:command]
+      end
+
+      def parameters
+        parse[:params]
+      end
+
+      def to_s
+        @message
+      end
+
+      protected
+
+      def strip_prefixes(params)
+        result = []
+        params.each_with_index do |param, i|
+          if param.match /^:(.*)/
+            result << params[i..params.length].join("\s").sub(":", "")
+            return result
+          else
+            result << param
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flamethrower/irc/user.rb

@@ -0,0 +1,33 @@
+module Flamethrower
+  module Irc
+    class User
+
+      attr_accessor :username, :nickname, :hostname, :realname, :servername, :modes
+
+      def initialize(options={})
+        @username = options[:username]
+        @nickname = options[:nickname]
+        @hostname = options[:hostname]
+        @realname = options[:realname]
+        @servername = options[:servername]
+        @modes = ["i"]
+      end
+
+      def nick_set?
+        !!@nickname
+      end
+
+      def user_set?
+        !!@username && !!@hostname && !!@realname && !!@servername
+      end
+
+      def mode
+        "+#{@modes.join}"
+      end
+
+      def to_s
+        "#{@nickname}!#{@username}@#{@hostname}"
+      end
+    end
+  end
+end