firering 0.1.1 → 1.0.0

data/lib/firering/data/room.rb

@@ -1,13 +1,120 @@
-module Firering
-  class Room < Firering::Data
-    key :id, :name, :topic, :membership_limit, :full, :open_to_guests, :active_token_value, :updated_at, :created_at, :users, :locked
+class Firering::Room < Firering::Data
 
-    alias_method :locked?, :locked
-    alias_method :full?, :full
-    alias_method :open_to_guests?, :open_to_guests
+  data_attributes :id, :name, :topic, :membership_limit, :full, :open_to_guests,
+    :active_token_value, :updated_at, :created_at, :users, :locked
 
-    def users
-      @users ||= (super || []).map { |u| Firering::User.new(u, false) }
+  alias_method :locked?, :locked
+  alias_method :full?, :full
+  alias_method :open_to_guests?, :open_to_guests
+
+  def stream(&callback)
+    join { |data, http| connection.stream(id, &callback) }
+  end
+
+  # we perform a request each time so
+  # 1) we always are are up to date with the users currently on the room (even if some left)
+  # 2) we make sure the users are here even if the room was instantiated from a
+  # /rooms request
+  def users(&callback)
+    connection.http(:get, "/room/#{id}.json") do |data, http| # data can be blank on locked rooms
+      callback.call(data ? data[:room][:users].map { |user| Firering::User.instantiate(self, user) } : Array.new) if callback
+    end
+  end
+
+  # Updates an existing room. Only admins can rename a room, although any
+  # user (except guests) may set the topic. Omitting either key results in
+  # that attribute being ignored. To remove a room topic, simply provide an
+  # empty topic key.
+  #
+  # update "name" => "Name", "topic" => "Topic"
+  def update(data, &callback)
+    connection.http(:put, "/room/#{id}.json", { :room => data }, &callback)
+  end
+
+  # Returns a collection of upto 100 recent messages in the room. Accepts an
+  # additional optional parameter ‘limit’ to restrict the number of messages
+  # returned.
+  def recent_messages(limit = nil, &callback)
+    connection.http(:get, "/room/#{id}/recent.json", (limit ? { :limit => limit } : nil)) do |data, http|
+      callback.call(data[:messages].map { |msg| Firering::Message.instantiate(connection, msg) }) if callback
     end
   end
+
+  # Returns all the messages sent today to a room.
+  def today_transcript(&callback)
+    connection.http(:get, "/room/#{id}/transcript.json") do |data, http|
+      callback.call(data[:messages].map { |msg| Firering::Message.instantiate(connection, msg) }) if callback
+    end
+  end
+
+  # Returns all the messages sent on a specific date to a room.
+  def transcript(year, month, day, &callback)
+    connection.http(:get, "/room/#{id}/transcript/#{year}/#{month}/#{day}.json") do |data, http|
+      callback.call(data[:messages].map { |msg| Firering::Message.instantiate(connection, msg) }) if callback
+    end
+  end
+
+  # Join a room.
+  def join(&callback)
+    connection.http(:post, "/room/#{id}/join.json", &callback)
+  end
+
+  # Leave a room.
+  def leave(&callback)
+    connection.http(:post, "/room/#{id}/leave.json", &callback)
+  end
+
+  # Locks a room.
+  def lock(&callback)
+    connection.http(:post, "/room/#{id}/lock.json", &callback)
+  end
+
+  # Unlocks a room.
+  def unlock(&callback)
+    connection.http(:post, "/room/#{id}/unlock.json", &callback)
+  end
+
+  # Sends a new message with the currently authenticated user as the sender.
+  # The XML for the new message is returned on a successful request.
+  #
+  # The valid types are:
+  #
+  # * TextMessage  (regular chat message)
+  # * PasteMessage (pre-formatted message, rendered in a fixed-width font)
+  # * SoundMessage (plays a sound as determined by the message, which can be either “rimshot”, “crickets”, or “trombone”)
+  # * TweetMessage (a Twitter status URL to be fetched and inserted into the chat)
+  #
+  # If an explicit type is omitted, it will be inferred from the content (e.g.,
+  # if the message contains new line characters, it will be considered a paste).
+  #
+  # :type => "TextMessage",  :body => "Hello"
+  def speak(data, &callback)
+    connection.http(:post, "/room/#{id}/speak.json", "message" => data) do |data, http| # Response Status: 201 Created
+      callback.call(Firering::Message.instantiate(connection, data))
+    end
+  end
+
+  def text(text, &callback)
+    speak({:type => "TextMessage", :body => text}, &callback)
+  end
+
+  def paste(paste, &callback)
+    speak({:type => "PasteMessage", :body => paste}, &callback)
+  end
+
+  def rimshot(&callback)
+    speak({:type => "SoundMessage", :body => "rimshot"}, &callback)
+  end
+
+  def crickets(&callback)
+    speak({:type => "SoundMessage", :body => "crickets"}, &callback)
+  end
+
+  def trombone(&callback)
+    speak({:type => "SoundMessage", :body => "trombone"}, &callback)
+  end
+
+  def tweet(tweet_url, &callback)
+    speak({:type => "TweetMessage", :body => tweet_url}, &callback)
+  end
 end

data/lib/firering/data/upload.rb

@@ -1,5 +1,6 @@
-module Firering
-  class Upload < Firering::Data
-    key :id, :name, :room_id, :user_id, :byte_size, :content_type, :full_url, :created_at
-  end
+class Firering::Upload < Firering::Data
+
+  data_attributes :id, :name, :room_id, :user_id, :byte_size, :content_type,
+    :full_url, :created_at
+
 end

data/lib/firering/data/user.rb

@@ -1,16 +1,18 @@
-module Firering
-  class User  < Firering::Data
-    key :id, :name, :email_address, :admin, :created_at, :type, :api_auth_token
+class Firering::User < Firering::Data
 
-    alias_method :token, :api_auth_token
-    alias_method :admin?, :admin
+  data_attributes :id, :name, :email_address, :admin, :created_at, :type,
+    :api_auth_token
 
-    def member?
-      type == "Member"
-    end
+  alias_method :token, :api_auth_token
+  alias_method :admin?, :admin
 
-    def gest?
-      type == "Guest"
-    end
+  def member?
+    type == "Member"
   end
+
+  def gest?
+    type == "Guest"
+  end
+
+  alias_method :to_s, :name
 end

data/lib/firering/data.rb

@@ -1,35 +1,42 @@
 module Firering
   class Data
+    # Generates methods to access the data stored in the @data Hash
+    def self.data_attributes(*keys)
+      include Module.new {
+        keys.each do |key|
+          module_eval <<-CODE, __FILE__, __LINE__
+            def #{key}
+              @_attributes[#{key.to_sym.inspect}]
+            end
+          CODE
+        end
+      }
+    end
 
-    # generates methods to access the data stored in the @data Hash
-    def self.key(*keys)
-      methods = keys.map do |key|
-        <<-CODE
-          def #{key}
-            @data[#{key.to_sym.inspect}]
-          end
-        CODE
-      end
+    attr_accessor :connection
 
-      include(Module.new do
-        module_eval methods.join("\n"), __FILE__, __LINE__
-      end)
+    # factory method to instantiate data classes
+    def self.instantiate(conn, data, base_key= nil, &callback)
+      instance = new
+      instance.connection = conn
+      instance.initialize_attributes(data, base_key)
+      callback.call(instance) if callback
+      instance
     end
 
     # data is a hash or a json encoded hash (String)
     # base_key if present is the main data key on the hash.
-    def initialize(data, base_key = nil)
-      @data = data.is_a?(Hash) ? data : Yajl::Parser.parse(data, :symbolize_keys => true)
-      @data = @data[base_key] if base_key
+    def initialize_attributes(data, base_key = nil)
+      @_attributes = data.is_a?(Hash) ? data : Yajl::Parser.parse(data, :symbolize_keys => true)
+      @_attributes = @_attributes[base_key] if base_key
 
-      @data.each do |key, val|
-        @data[key] = Date.parse(val) rescue val if key.to_s =~ /(_at|_on)$/
+      @_attributes.each do |key, val|
+        @_attributes[key] = Date.parse(val) rescue val if key.to_s =~ /(_at|_on)$/
       end
     end
 
     def inspect
-      "<#{self.class.name} #{@data.inspect}>"
+      "<#{self.class.name} #{@_attributes.inspect}>"
     end
-
   end
 end

data/lib/firering/requests.rb

@@ -1,185 +1,49 @@
 module Firering
-  include Firering::HTTP
-  include Firering::Streaming
+  module Requests
 
-  extend self
-
-  attr_accessor :token, :subdomain
-
-  # calls /users/me route on campfire to get the authenticated user information, including token
-  def authenticate(subdomain, user, password, &block)
-    Firering.subdomain = subdomain
-    user("me", user, password) do |user|
-      Firering.token = user.token
-      block.call(user)
-    end
-  end
-
-  # non default user and password parameters are only used when user id is "me"
-  # to authenticate the user and get his auth token.
-  def user(id, user = Firering.token, password = "X", &block)
-    http(:get, "/users/#{id}.json", nil, user, password) do |http|
-      user = Firering::User.new(http.response, :user)
-      block.call(user)
-    end
-  end
-
-  # returns all rooms. For getting the users, each specific room must be queries with Firering.room
-  # multi: if true, gets all the users from each room as Firering::User objects
-  def rooms(multi = true, &block)
-    http(:get, "/rooms.json") do |http|
-
-      rooms = Yajl::Parser.parse(http.response, :symbolize_keys => true)[:rooms]
-      rooms.map! { |room| Firering::Room.new(room) }
-
-      if multi
-        rooms_multi(rooms, &block)
-      else
-        block.call(rooms)
+    # Calls /users/me route on campfire to get the authenticated user information, including token
+    def authenticate(&callback)
+      user("me") do |user|
+        self.token = user.token
+        callback.call(user)
       end
     end
-  end
-
-  # helper for returning all rooms with all existing users (saves the step of going through each room)
-  def rooms_multi(rooms, &block)
-    multi = EventMachine::MultiRequest.new
-    final_rooms = []
 
-    rooms.each do |room|
-      if room.locked? # can't retrieve aditional info on a locked room.
-        final_rooms << room
-      else
-        multi.add(room(room.id) { |req_room| final_rooms << req_room })
+    # returns a user by id
+    def user(id, &callback)
+      http(:get, "/users/#{id}.json") do |data, http|
+        Firering::User.instantiate(self, data, :user, &callback)
       end
     end
 
-    multi.callback  { block.call(final_rooms) }
-  end
-
-  # Returns an existing room. Also includes all the users currently inside the room.
-  def room(id, &block)
-    http(:get, "/room/#{id}.json") do |http|
-      room = Firering::Room.new(http.response, :room)
-      block.call(room)
-    end
-  end
-
-  # Updates an existing room. Only admins can rename a room, although any
-  # user (except guests) may set the topic. Omitting either tag results in
-  # that attribute being ignored. To remove a room topic, simply provide an
-  # empty topic tag.
-  #
-  # update_room "1", "name" => "Name", "topic" => "Topic"
-  def update_room(id, data, &block)
-    http(:put, "/room/#{id}.json", { :room => data }, &block)
-  end
-
-  # Returns a collection of upto 100 recent messages in the room. Accepts an
-  # additional optional parameter ‘limit’ to restrict the number of messages
-  # returned.
-  def room_recent_messages(id, limit = nil, &block)
-    http(:get, "/room/#{id}/recent.json", (limit ? { :limit => limit } : nil)) do |http|
-      messages = Yajl::Parser.parse(http.response, :symbolize_keys => true)[:messages]
-      messages.map! { |msg| Firering::Message.new(msg) }
-      block.call(messages)
-    end
-  end
-
-  # Returns all the messages containing the supplied term.
-  def search_messages(query, &block)
-    http(:get, "/search/#{query}.json") do |http|
-      messages = Yajl::Parser.parse(http.response, :symbolize_keys => true)[:messages]
-      messages.map! { |msg| Firering::Message.new(msg) }
-      block.call(messages)
+    # returns a room by id
+    def room(id, &callback)
+      http(:get, "/room/#{id}.json") do |data, http|
+        Firering::Room.instantiate(self, data, :room, &callback)
+      end
     end
-  end
 
-  # Returns all the messages sent today to a room.
-  def today_messages(room_id, &block)
-    http(:get, "/room/#{room_id}/transcript.json") do |http|
-      messages = Yajl::Parser.parse(http.response, :symbolize_keys => true)[:messages]
-      messages.map! { |msg| Firering::Message.new(msg) }
-      block.call(messages)
+    # Returns all rooms. For getting the users, each specific room must be queries with Firering.room
+    # multi: if true, gets all the users from each room as Firering::User objects
+    def rooms(&callback)
+      http(:get, "/rooms.json") do |data, http|
+        callback.call(data[:rooms].map{|room| Firering::Room.instantiate(self, room)}) if callback
+      end
     end
-  end
 
-  # Returns all the messages sent on a specific date to a room.
-  def messages_on(room_id, year, month, day, &block)
-    http(:get, "/room/#{room_id}/transcript/#{year}/#{month}/#{day}.xml") do |http|
-      messages = Yajl::Parser.parse(http.response, :symbolize_keys => true)[:messages]
-      messages.map! { |msg| Firering::Message.new(msg) }
-      block.call(messages)
+    # Returns all the messages containing the supplied term.
+    def search_messages(query, &callback)
+      http(:get, "/search/#{query}.json") do |data, http|
+        callback.call(data[:messages].map { |msg| Firering::Message.instantiate(self, msg) }) if callback
+      end
     end
-  end
-
-  # Join a room.
-  def room_join(room_id, &block)
-    http(:post, "/room/#{room_id}/join.json", &block)
-  end
 
-  # Leave a room.
-  def room_leave(room_id, &block)
-    http(:post, "/room/#{room_id}/leave.json", &block)
-  end
-
-  # Locks a room.
-  def room_lock(room_id, &block)
-    http(:post, "/room/#{room_id}/lock.json", &block)
-  end
-
-  # Unlocks a room.
-  def room_unlock(room_id, &block)
-    http(:post, "/room/#{room_id}/unlock.json", &block)
-  end
-
-  # Sends a new message with the currently authenticated user as the sender.
-  # The XML for the new message is returned on a successful request.
-  #
-  # The valid types are:
-  #
-  # * TextMessage  (regular chat message)
-  # * PasteMessage (pre-formatted message, rendered in a fixed-width font)
-  # * SoundMessage (plays a sound as determined by the message, which can be either “rimshot”, “crickets”, or “trombone”)
-  # * TweetMessage (a Twitter status URL to be fetched and inserted into the chat)
-  #
-  # If an explicit type is omitted, it will be inferred from the content (e.g.,
-  # if the message contains new line characters, it will be considered a paste).
-  #
-  # :type => "TextMessage",  :body => "Hello"
-  def speak(room_id, data, &block)
-    # Response Status: 201 Created
-    http(:post, "/room/#{room_id}/speak.json", "message" => data) do |http|
-      block.call(Firering::Message.new(http.response))
+    # Toggles the star next to a message
+    def star_message(id, yes_or_no = true, &callback)
+      http(yes_or_no ? :post : :delete, "/messages/#{id}/star.json") do |data, http|
+        callback.call(data) if callback
+      end
     end
-  end
 
-  def text(room_id, text, &block)
-    speak(room_id, {:type => "TextMessage", :body => text}, &block)
   end
-
-  def paste(room_id, paste, &block)
-    speak(room_id, {:type => "PasteMessage", :body => paste}, &block)
-  end
-
-  def rimshot(room_id, &block)
-    speak(room_id, {:type => "SoundMessage", :body => "rimshot"}, &block)
-  end
-
-  def crickets(room_id, &block)
-    speak(room_id, {:type => "SoundMessage", :body => "crickets"}, &block)
-  end
-
-  def trombone(room_id, &block)
-    speak(room_id, {:type => "SoundMessage", :body => "trombone"}, &block)
-  end
-
-  def tweet(room_id, tweet_url, &block)
-    speak(room_id, {:type => "TweetMessage", :body => tweet_url}, &block)
-  end
-
-  # Highlights a message / Removes a message highlight.
-  def highlight_message(message_id, yes_or_no = true, &block)
-    http(yes_or_no ? :post : :delete, "/messages/#{message_id}/star.json", &block)
-  end
-
 end

data/lib/firering.rb

@@ -1,21 +1,20 @@
+require 'logger'
+require 'date'
 require 'eventmachine'
 require 'yajl'
 require 'em-http'
-require 'date'
 
 module Firering
-  VERSION = '0.1.1'
+  VERSION = '1.0.0'
 
   class Error < StandardError; end
 
-  autoload :Data    , "firering/data"
+  autoload :Requests   , "firering/requests"
+  autoload :Connection , "firering/connection"
 
-  autoload :User    , "firering/data/user"
-  autoload :Message , "firering/data/message"
-  autoload :Room    , "firering/data/room"
-  autoload :Upload  , "firering/data/upload"
+  autoload :Data       , "firering/data"
+  autoload :User       , "firering/data/user"
+  autoload :Message    , "firering/data/message"
+  autoload :Room       , "firering/data/room"
+  autoload :Upload     , "firering/data/upload"
 end
-
-require 'firering/http'
-require 'firering/streaming'
-require 'firering/requests'

data/log/.gitignore

@@ -0,0 +1 @@
+*

data/spec/firering/connection_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Firering::Connection do
+
+  it "authenticates a user" do
+    EM.run {
+      conn.authenticate do |user|
+        user.token.should == "token"
+        EM.stop
+      end
+    }
+  end
+
+  it "stream messages" do
+    EM.run {
+      conn.stream(304355) do |message|
+        message.should be_an_instance_of(Firering::Message)
+      end
+      EM.add_timer(1) do
+        EM.stop
+      end
+    }
+  end
+
+end

data/spec/firering/data/message_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Firering::Message do
+
+  it "gets a collection of recent messages" do
+    EM.run {
+      conn.room(304355) do |room|
+        room.recent_messages do |messages|
+
+          messages.each do |m|
+            m.should be_an_instance_of(Firering::Message)
+          end
+
+          message = messages.first
+          message.should be_timestamp
+          message.room_id.should == 304355
+          message.created_at.should == Date.parse("2010/05/29 22:05:00 +0000")
+          message.body.should be_nil
+          message.id.should == 224587718
+          message.user_id.should be_nil
+
+          EM.stop
+
+        end
+      end
+    }
+  end
+
+  it "returns a collection of messages matching certain pattern" do
+    EM.run {
+      conn.search_messages("harmless") do |messages|
+        messages.length.should == 3
+
+        messages.each do |m|
+          m.should be_an_instance_of(Firering::Message)
+        end
+
+        message = messages.last
+        message.should be_text
+        message.room_id.should == 177718
+        message.created_at.should == Date.parse("2009/06/02 21:20:32 +0000")
+        message.body.should == "q: should i add :case_sensitive =\u003E false to the validation of title name? Looks harmless but who knows..."
+        message.id.should == 134405854
+        message.user_id.should == 415731
+
+        EM.stop
+      end
+    }
+  end
+
+  it "is able to star / un-star a message" do
+    EM.run {
+      conn.star_message(224590113) {
+        conn.star_message(224590113, false) {
+          EM.stop
+        }
+      }
+    }
+  end
+
+end