tinder 1.3.1 → 1.10.1

data/lib/tinder/room.rb

@@ -1,37 +1,36 @@
+# encoding: UTF-8
+require 'time'
+
 module Tinder
   # A campfire room
   class Room
     attr_reader :id, :name
 
-    def initialize(campfire, attributes = {})
-      @campfire = campfire
+    def initialize(connection, attributes = {})
+      @connection = connection
       @id = attributes['id']
       @name = attributes['name']
       @loaded = false
     end
 
-    # Join the room. Pass +true+ to join even if you've already joined.
-    def join(force = false)
-      post 'join'
+    # Join the room
+    # POST /room/#{id}/join.xml
+    # For whatever reason, #join() and #leave() are still xml endpoints
+    # whereas elsewhere in this API we're assuming json :\
+    def join
+      post 'join', 'xml'
     end
 
     # Leave a room
+    # POST /room/#{id}/leave.xml
     def leave
-      post 'leave'
-    end
-
-    # Toggle guest access on or off
-    def toggle_guest_access
-      raise NotImplementedError
+      post 'leave', 'xml'
+      stop_listening
     end
 
     # Get the url for guest access
     def guest_url
-      if guest_access_enabled?
-        "http://#{@campfire.subdomain}.campfirenow.com/#{guest_invite_code}"
-      else
-        nil
-      end
+      "#{@connection.uri}/#{guest_invite_code}" if guest_access_enabled?
     end
 
     def guest_access_enabled?
@@ -47,37 +46,33 @@ module Tinder
 
     # Change the name of the room
     def name=(name)
-      connection.post("/room/#{@id}.json", :body => { :room => { :name => name } })
+      update :name => name
     end
     alias_method :rename, :name=
 
     # Change the topic
     def topic=(topic)
-      connection.post("/room/#{@id}.json", :body => { :room => { :topic => name } })
+      update :topic => topic
+    end
+
+    def update(attrs)
+      connection.put("/room/#{@id}.json", {:room => attrs})
     end
 
     # Get the current topic
     def topic
-      load
+      reload!
       @topic
     end
 
     # Lock the room to prevent new users from entering and to disable logging
     def lock
-      post :lock
+      post 'lock'
     end
 
     # Unlock the room
     def unlock
-      post :unlock
-    end
-
-    def ping(force = false)
-      raise NotImplementedError
-    end
-
-    def destroy
-      raise NotImplementedError
+      post 'unlock'
     end
 
     # Post a new message to the chat room
@@ -89,50 +84,129 @@ module Tinder
       send_message(message, 'PasteMessage')
     end
 
+    def play(sound)
+      send_message(sound, 'SoundMessage')
+    end
+
+    def tweet(url)
+      send_message(url, 'TweetMessage')
+    end
+
     # Get the list of users currently chatting for this room
     def users
+      @users ||= current_users
+    end
+
+    def current_users
       reload!
-      @users
+      @current_users
     end
 
-    # Get and array of the messages that have been posted to the room. Each
-    # messages is a hash with:
-    # * +:person+: the display name of the person that posted the message
-    # * +:message+: the body of the message
-    # * +:user_id+: Campfire user id
-    # * +:id+: Campfire message id
-    #
-    #   room.listen
-    #   #=> [{:person=>"Brandon", :message=>"I'm getting very sleepy", :user_id=>"148583", :id=>"16434003"}]
+    # return the user with the given id; if it isn't in our room cache,
+    # do a request to get it
+    def user(id)
+      if id
+        cached_user = users.detect {|u| u[:id] == id }
+        user = cached_user || fetch_user(id)
+        self.users << user
+        user
+      end
+    end
+
+    # Perform a request for the user with the given ID
+    def fetch_user(id)
+      user_data = connection.get("/users/#{id}.json")
+      user = user_data && user_data[:user]
+      user[:created_at] = Time.parse(user[:created_at])
+      user
+    end
+
+    # Modifies a hash representation of a Campfire message.  Expands +:user_id+
+    # to a full hash at +:user+, generates Timestamp from +:created_at+.
     #
-    # Called without a block, listen will return an array of messages that have been
-    # posted since you joined. listen also takes an optional block, which then polls
-    # for new messages every 5 seconds and calls the block for each message.
+    # Full returned hash:
+    # * +:body+: the body of the message
+    # * +:user+: Campfire user, which is itself a hash, of:
+    #   * +:id+: User id
+    #   * +:name+: User name
+    #   * +:email_address+: Email address
+    #   * +:admin+: Boolean admin flag
+    #   * +:created_at+: User creation timestamp
+    #   * +:type+: User type (e.g. Member)
+    # * +:id+: Campfire message id
+    # * +:type+: Campfire message type
+    # * +:room_id+: Campfire room id
+    # * +:created_at+: Message creation timestamp
+    def parse_message(message)
+      message[:user] = user(message.delete(:user_id))
+      message[:created_at] = Time.parse(message[:created_at])
+      message
+    end
+
+    # Listen for new messages in the room, parsing them with #parse_message
+    # and then yielding them to the provided block as they arrive.
     #
     #   room.listen do |m|
-    #     room.speak "#{m[:person]}, Go away!" if m[:message] =~ /Java/i
+    #     room.speak "Go away!" if m[:body] =~ /Java/i
     #   end
-    #
-    def listen(interval = 5)
-      require 'yajl/http_stream'
-
-      auth = connection.default_options[:basic_auth]
-      url = URI.parse("http://#{auth[:username]}:#{auth[:password]}@streaming.#{Campfire::HOST}/room/#{@id}/live.json")
-      Yajl::HttpStream.get(url) do |message|
-        { :id => message['id'],
-          :user_id => message['user_id'],
-          :message => message['body'] }
+    def listen(options = {})
+      raise ArgumentError, "no block provided" unless block_given?
+
+      Tinder.logger.info "Joining #{@name}…"
+      join # you have to be in the room to listen
+
+      require 'json'
+      require 'hashie'
+      require 'multi_json'
+      require 'twitter/json_stream'
+
+      auth = connection.basic_auth_settings
+      options = {
+        :host => "streaming.#{Connection::HOST}",
+        :path => room_url_for('live'),
+        :auth => "#{auth[:username]}:#{auth[:password]}",
+        :timeout => 6,
+        :ssl => connection.options[:ssl]
+      }.merge(options)
+
+      Tinder.logger.info "Starting EventMachine server…"
+      EventMachine::run do
+        @stream = Twitter::JSONStream.connect(options)
+        Tinder.logger.info "Listening to #{@name}…"
+        @stream.each_item do |message|
+          message = Hashie::Mash.new(MultiJson.decode(message))
+          message = parse_message(message)
+          yield(message)
+        end
+
+        @stream.on_error do |message|
+          raise ListenFailed.new("got an error! #{message.inspect}!")
+        end
+
+        @stream.on_max_reconnects do |timeout, retries|
+          raise ListenFailed.new("Tried #{retries} times to connect. Got disconnected from #{@name}!")
+        end
+
+        # if we really get disconnected
+        raise ListenFailed.new("got disconnected from #{@name}!") if !EventMachine.reactor_running?
       end
     end
 
-    # Get the dates for the available transcripts for this room
-    def available_transcripts
-      raise NotImplementedError
+    def listening?
+      @stream != nil
+    end
+
+    def stop_listening
+      return unless listening?
+
+      Tinder.logger.info "Stopped listening to #{@name}…"
+      @stream.stop
+      @stream = nil
     end
 
     # Get the transcript for the given date (Returns a hash in the same format as #listen)
     #
-    #   room.transcript(room.available_transcripts.first)
+    #   room.transcript(Time.now)
     #   #=> [{:message=>"foobar!",
     #         :user_id=>"99999",
     #         :person=>"Brandon",
@@ -141,65 +215,99 @@ module Tinder
     #
     # The timestamp slot will typically have a granularity of five minutes.
     #
-    def transcript(transcript_date)
-      url = "/room/#{@id}/transcript/#{transcript_date.to_date.strftime('%Y/%m/%d')}.json"
-      connection.get(url)['messages'].map do |room|
-        { :id => room['id'],
-          :user_id => room['user_id'],
-          :message => room['body'],
-          :timestamp => Time.parse(room['created_at']) }
+    def transcript(transcript_date = Date.today)
+      url = "/room/#{@id}/transcript/#{transcript_date.strftime('%Y/%m/%d')}.json"
+      connection.get(url)['messages'].map do |message|
+        parse_message(message)
       end
     end
 
-    def upload(filename)
-      File.open(filename, "rb") do |file|
-        params = Multipart::MultipartPost.new('upload' => file)
-        connection.post("/room/#{@id}/uploads.json", :body => params.query)
+    # Search transcripts for the given term (returns an array of messages parsed
+    # via #parse_message, see #parse_message for format of returned message)
+    #
+    def search(term)
+      encoded_term = URI.encode(term)
+
+      room_messages = connection.get("/search/#{encoded_term}.json")["messages"].select do |message|
+        message[:room_id] == id
+      end
+
+      room_messages.map do |message|
+        parse_message(message)
       end
     end
 
+    def upload(file, content_type = nil, filename = nil)
+      require 'mime/types'
+      content_type ||= MIME::Types.type_for(filename || file)
+      raw_post(:uploads, { :upload => Faraday::UploadIO.new(file, content_type, filename) })
+    end
+
     # Get the list of latest files for this room
     def files(count = 5)
-      connection.get(room_url_for(:uploads))['uploads'].map { |u| u['full_url'] }
+      get(:uploads)['uploads'].map { |u| u['full_url'] }
     end
 
-    protected
-      def load
-        reload! unless @loaded
+    # Get a list of recent messages
+    # Accepts a hash for options:
+    # * +:limit+: Restrict the number of messages returned
+    # * +:since_message_id+: Get messages created after the specified message id
+    def recent(options = {})
+      options = { :limit => 10, :since_message_id => nil }.merge(options)
+      # Build url manually, faraday has to be 8.0 to do this
+      url = "#{room_url_for(:recent)}?limit=#{options[:limit]}&since_message_id=#{options[:since_message_id]}"
+
+      connection.get(url)['messages'].map do |msg|
+        parse_message(msg)
       end
+    end
 
-      def reload!
-        attributes = connection.get("/room/#{@id}.json")['room']
+  protected
 
-        @id = attributes['id']
-        @name = attributes['name']
-        @topic = attributes['topic']
-        @full = attributes['full']
-        @open_to_guests = attributes['open-to-guests']
-        @active_token_value = attributes['active-token-value']
-        @users = attributes['users'].map { |u| u['name'] }
+    def load
+      reload! unless @loaded
+    end
 
-        @loaded = true
-      end
+    def reload!
+      attributes = connection.get("/room/#{@id}.json")['room']
 
-      def send_message(message, type = 'Textmessage')
-        post 'speak', :body => {:message => {:body => message, :type => type}}.to_json
+      @id = attributes['id']
+      @name = attributes['name']
+      @topic = attributes['topic']
+      @full = attributes['full']
+      @open_to_guests = attributes['open_to_guests']
+      @active_token_value = attributes['active_token_value']
+      @current_users = attributes['users'].map do |user|
+        user[:created_at] = Time.parse(user[:created_at])
+        user
       end
 
-      def get(action, options = {})
-        connection.get(room_url_for(action), options)
-      end
+      @loaded = true
+    end
 
-      def post(action, options = {})
-        connection.post(room_url_for(action), options)
-      end
+    def send_message(message, type = 'TextMessage')
+      post 'speak', {:message => {:body => message, :type => type}}
+    end
 
-      def room_url_for(action)
-        "/room/#{@id}/#{action}.json"
-      end
+    def get(action)
+      connection.get(room_url_for(action))
+    end
+
+    def post(action, body = nil)
+      connection.post(room_url_for(action), body)
+    end
+
+    def raw_post(action, body = nil)
+      connection.raw_post(room_url_for(action), body)
+    end
+
+    def room_url_for(action, format="json")
+      "/room/#{@id}/#{action}.#{format}"
+    end
+
+    def connection
+      @connection
+    end
 
-      def connection
-        @campfire.connection
-      end
   end
 end

data/lib/tinder/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module Tinder
+  VERSION = '1.10.1' unless defined?(::Tinder::VERSION)
+end

data/lib/tinder.rb

@@ -1,16 +1,20 @@
-require 'rubygems'
-require 'active_support'
-require 'uri'
-require 'net/http'
-require 'net/https'
-require 'open-uri'
-
+# encoding: UTF-8
 require 'tinder/connection'
-require 'tinder/multipart'
 require 'tinder/campfire'
 require 'tinder/room'
+require 'logger'
 
 module Tinder
   class Error < StandardError; end
   class SSLRequiredError < Error; end
+  class AuthenticationFailed < Error; end
+  class ListenFailed < Error; end
+
+  def self.logger
+    @logger ||= Logger.new(ENV['TINDER_LOGGING'] ? STDOUT : nil)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
 end

data/site/index.html

@@ -34,7 +34,7 @@
     <div id="content">
         <p>Tinder is an API for interfacing with <a href="http://campfirenow.com">Campfire</a>, the 37Signals chat application.</p>
         <h2>Example</h2>
-        
+
         <pre><code class="ruby">campfire = Tinder::Campfire.new 'mysubdomain'
 campfire.login 'myemail@example.com', 'mypassword'</code></pre>
 
@@ -77,17 +77,17 @@ campfire.users # users in all rooms</code></pre>
         <p>See the <a href="tinder">API documentation</a> for more details.</p>
 
         <h2>Installation</h2>
-        
+
         <p>Tinder can be installed as a gem or a Rails plugin. Install the gem by executing:</p>
-        
+
         <pre>gem install tinder</pre>
-        
+
         <p>Or, download it from <a href="http://rubyforge.org/frs/?group_id=2922">RubyForge</a>.</p>
-        
+
         <h2>Source</h2>
-        
+
         <p>Contributions are welcome and appreciated!  The source is available from:</p>
-        
+
         <pre>http://github.com/collectiveidea/tinder</pre>
     </div>
 </div>

data/spec/fixtures/presence.json

@@ -0,0 +1,26 @@
+{"rooms": [
+  {
+    "name": "Room 1",
+    "created_at": "2007/03/16 18:03:21 +0000",
+    "updated_at": "2007/03/16 18:03:21 +0000",
+    "topic": "Testing",
+    "id": 80749,
+    "membership_limit": 4
+  },
+  {
+    "name": "Room 2",
+    "created_at": "2007/03/16 18:04:54 +0000",
+    "updated_at": "2007/03/16 18:04:54 +0000",
+    "topic": "test",
+    "id": 80751,
+    "membership_limit": 4
+  },
+  {
+    "name": "Room 3",
+    "created_at": "2012/03/16 18:04:54 +0000",
+    "updated_at": "2013/03/16 18:04:54 +0000",
+    "topic": "presence",
+    "id": 80754,
+    "membership_limit": 4
+  }]
+}

data/spec/fixtures/rooms/recent.json

@@ -0,0 +1,19 @@
+{
+    "messages": [{
+        "starred": false,
+        "type": "TextMessage",
+        "room_id": 490096,
+        "created_at": "2012/04/05 10:53:14 +0000",
+        "id": 537713173,
+        "user_id": 1158839,
+        "body": "https://github.com/technomancy/dotfiles/commit/e19989d33777bb392c0ad1205444762dfecbaa5f "
+    }, {
+        "starred": false,
+        "type": "TextMessage",
+        "room_id": 490096,
+        "created_at": "2012/04/05 10:54:20 +0000",
+        "id": 537713420,
+        "user_id": 1158837,
+        "body": "Lol"
+    }]
+}

data/spec/fixtures/rooms/room80749.json

@@ -0,0 +1,21 @@
+{
+    "room": {
+        "full": false,
+        "name": "Room 1",
+        "created_at": "2007/03/16 18:03:21 +0000",
+        "updated_at": "2007/03/16 18:03:21 +0000",
+        "users": [{
+            "type": "Member",
+            "created_at": "2006/12/07 21:20:39 +0000",
+            "email_address": "jane@example.com",
+            "admin": true,
+            "id": 1,
+            "name": "Jane Doe"
+        }],
+        "topic": "Testing",
+        "active_token_value": "90cf7",
+        "id": 80749,
+        "open_to_guests": true,
+        "membership_limit": 4
+    }
+}

data/spec/fixtures/rooms/room80751.json

@@ -0,0 +1,21 @@
+{
+    "room": {
+        "full": false,
+        "name": "Room 2",
+        "created_at": "2007/03/16 18:03:21 +0000",
+        "updated_at": "2007/03/16 18:03:21 +0000",
+        "users": [{
+            "type": "Member",
+            "created_at": "2006/12/07 21:20:39 +0000",
+            "email_address": "john@example.com",
+            "admin": true,
+            "id": 2,
+            "name": "John Doe"
+        }],
+        "topic": "Testing 2",
+        "active_token_value": "90cf7",
+        "id": 80751,
+        "open_to_guests": true,
+        "membership_limit": 4
+    }
+}

data/spec/fixtures/rooms/show.json

@@ -0,0 +1,21 @@
+{
+    "room": {
+        "full": false,
+        "name": "Room 1",
+        "created_at": "2007/03/16 18:03:21 +0000",
+        "updated_at": "2007/03/16 18:03:21 +0000",
+        "users": [{
+            "type": "Member",
+            "created_at": "2006/12/07 21:20:39 +0000",
+            "email_address": "brandon@opensoul.org",
+            "admin": true,
+            "id": 129553,
+            "name": "Brandon Keepers"
+        }],
+        "topic": "Testing",
+        "active_token_value": "90cf7",
+        "id": 80749,
+        "open_to_guests": true,
+        "membership_limit": 4
+    }
+}

data/spec/fixtures/rooms.json

@@ -0,0 +1,18 @@
+{"rooms": [
+  {
+    "name": "Room 1",
+    "created_at": "2007/03/16 18:03:21 +0000",
+    "updated_at": "2007/03/16 18:03:21 +0000",
+    "topic": "Testing",
+    "id": 80749,
+    "membership_limit": 4
+  },
+  {
+    "name": "Room 2",
+    "created_at": "2007/03/16 18:04:54 +0000",
+    "updated_at": "2007/03/16 18:04:54 +0000",
+    "topic": "test",
+    "id": 80751,
+    "membership_limit": 4
+  }]
+}

data/spec/fixtures/users/me.json

@@ -0,0 +1,11 @@
+{
+    "user": {
+        "email_address": "user@example.com",
+        "type": "Member",
+        "created_at": "2006/04/06 00:38:28 +0000",
+        "admin": true,
+        "id": 12345,
+        "name": "John Doe",
+        "api_auth_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    }
+}

data/spec/spec_helper.rb

@@ -1,3 +1,27 @@
-require 'rubygems'
-require 'spec'
+# encoding: UTF-8
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rspec'
 require 'tinder'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+def fixture(name)
+  File.read(File.dirname(__FILE__) + "/fixtures/#{name}")
+end
+
+def stub_connection(object, &block)
+  @stubs ||= Faraday::Adapter::Test::Stubs.new
+
+  object.connection.build do |builder|
+    builder.use     FaradayMiddleware::EncodeJson
+    builder.use     FaradayMiddleware::Mashify
+    builder.use     FaradayMiddleware::ParseJson
+    builder.use     Faraday::Response::RemoveWhitespace
+    builder.use     Faraday::Response::RaiseOnAuthenticationFailure
+    builder.adapter :test, @stubs
+  end
+
+  block.call(@stubs)
+end