timriley-tinder 1.1.9

data/CHANGELOG.txt

@@ -0,0 +1,30 @@
+0.1.7 - 2008-07-24
+* Don't join the room when only speaking [Brian Donovan]
+* Added support for HTTP proxies
+* Fix listening for messages that contain URLs [Jared Kuolt]
+
+0.1.6 - 2008-03-07
+* Added Room#topic for getting the current topic [Even Weaver]
+* Trap INT in #listen(&block) [borrowed from Chris Shea's Pyre]
+
+0.1.5 - 2008-01-25
+* Fixed Room#listen, which was broken by latest Campfire deploy
+* Fixed timeout when listening but not speaking that will eventually log you out [Clinton R. Nixon]
+
+0.1.4 - 2007-07-23
+* Support for transcripts
+* Fixed Room#leave, which was broken by a Campfire deployment [Andy Smith]
+
+0.1.3 - 2007-02-12
+* added ssl support [Tero Parviainen]
+
+0.1.2 - 2007-01-27
+* fixed bug preventing #listen from working without a block
+
+0.1.1 - 2007-01-27
+* fix bug preventing speak from working
+* incorporated "watching" from http://soylentfoo.jnewland.com/articles/2006/12/07/updates-to-marshmallow-the-campfire-bot
+
+0.1.0 - 2007-01-23
+* Initial release as gem
+* Get the users in a room [Tero Parviainen]

data/Manifest.txt

@@ -0,0 +1,9 @@
+CHANGELOG.txt
+Manifest.txt
+README.txt
+Rakefile
+init.rb
+lib/tinder.rb
+lib/tinder/campfire.rb
+lib/tinder/room.rb
+lib/tinder/version.rb

data/README.txt

@@ -0,0 +1,45 @@
+= Tinder - get the Campfire started
+
+This is a fork of tinder that provides file upload support, currently using the mechanize gem.
+
+Tinder is a library for interfacing with Campfire, the chat application from 37Signals. Unlike Marshmallow, it is designed to be a full-featured API (since 37Signals doesn't provide a real one), allowing you to programatically manage and speak/listen in chat rooms.
+
+== Usage
+
+  campfire = Campfire.new 'mysubdomain'
+  campfire.login 'myemail@example.com', 'mypassword'
+
+  room = campfire.create_room 'New Room', 'My new campfire room to test tinder'
+  room.rename 'New Room Name'
+  room.speak 'Hello world!'
+  room.paste "my pasted\ncode"
+  room.destroy
+
+  room = campfire.find_room_by_guest_hash 'abc123', 'John Doe'
+  room.speak 'Hello world!'
+  
+  See the RDoc for more details.
+
+== Requirements
+
+* Active Support
+  gem install activesupport
+* Hpricot
+  gem install hpricot
+  
+== Installation
+
+Tinder can be installed as a gem or a Rails plugin:
+
+  gem install tinder
+  
+  script/plugin install http://source.collectiveidea.com/public/tinder/trunk
+  
+== Development
+
+The source for Tinder is available at http://source.collectiveidea.com/public/tinder/trunk. Development can be followed at http://opensoul.org/tags/tinder.  Contributions are welcome!
+
+== ToDo
+
+* Tests! (unit and remote)
+* Marshmallow-style integration scripts for exception notification and continuous integration

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'hoe'
+require File.join(File.dirname(__FILE__), 'lib', 'tinder', 'version')
+
+# RDOC_OPTS = ['--quiet', '--title', "Tinder",
+#     "--opname", "index.html",
+#     "--line-numbers", 
+#     "--main", "README",
+#     "--inline-source"]
+# 
+# Generate all the Rake tasks
+
+hoe = Hoe.new('tinder', ENV['VERSION'] || Tinder::VERSION::STRING) do |p|
+  p.rubyforge_name = 'tinder'
+  p.summary = "An (unofficial) Campfire API"
+  p.description = "An API for interfacing with Campfire, the 37Signals chat application."
+  p.author = 'Brandon Keepers'
+  p.email = 'brandon@opensoul.org'
+  p.url = 'http://tinder.rubyforge.org'
+  p.test_globs = ["test/**/*_test.rb"]
+  p.changes = p.paragraphs_of('CHANGELOG.txt', 0..1).join("\n\n")
+  p.extra_deps << ['activesupport']
+  p.extra_deps << ['hpricot']
+end

data/init.rb

@@ -0,0 +1 @@
+require 'tinder'

data/lib/tinder.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'active_support'
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'open-uri'
+require 'hpricot'
+require 'mechanize'
+
+Dir[File.join(File.dirname(__FILE__), 'tinder/**/*.rb')].sort.each { |lib| require lib }
+
+module Tinder
+  class Error < StandardError; end
+  class SSLRequiredError < Error; end
+end

data/lib/tinder/campfire.rb

@@ -0,0 +1,211 @@
+module Tinder
+  
+  # == Usage
+  #
+  #   campfire = Tinder::Campfire.new 'mysubdomain'
+  #   campfire.login 'myemail@example.com', 'mypassword'
+  #
+  #   room = campfire.create_room 'New Room', 'My new campfire room to test tinder'
+  #   room.speak 'Hello world!'
+  #   room.destroy
+  #
+  #   room = campfire.find_room_by_guest_hash 'abc123', 'John Doe'
+  #   room.speak 'Hello world!'
+  class Campfire
+    attr_reader :subdomain, :uri
+
+    # Create a new connection to the campfire account with the given +subdomain+.
+    #
+    # == Options:
+    # * +:ssl+: use SSL for the connection, which is required if you have a Campfire SSL account.
+    #           Defaults to false
+    # * +:proxy+: a proxy URI. (e.g. :proxy => 'http://user:pass@example.com:8000')
+    #
+    #   c = Tinder::Campfire.new("mysubdomain", :ssl => true)
+    def initialize(subdomain, options = {})
+      options = { :ssl => false }.merge(options)
+      @cookie = nil
+      @subdomain = subdomain
+      @uri = URI.parse("#{options[:ssl] ? 'https' : 'http' }://#{subdomain}.campfirenow.com")
+      if options[:proxy]
+        uri = URI.parse(options[:proxy])
+        @http = Net::HTTP::Proxy(uri.host, uri.port, uri.user, uri.password)
+      else
+        @http = Net::HTTP
+      end
+      @logged_in = false
+    end
+    
+    # Log in to campfire using your +email+ and +password+
+    def login(email, password)
+      unless verify_response(post("login", :email_address => email, :password => password), :redirect_to => url_for(:only_path => false))
+        raise Error, "Campfire login failed"
+      end
+      # ensure that SSL is set if required on this account
+      raise SSLRequiredError, "Your account requires SSL" unless verify_response(get, :success)
+      @logged_in = true
+    end
+    
+    # Returns true when successfully logged in
+    def logged_in?
+      @logged_in == true
+    end
+  
+    def logout
+      returning verify_response(get("logout"), :redirect) do |result|
+        @logged_in = !result
+      end
+    end
+    
+    # Get an array of all the available rooms
+    # TODO: detect rooms that are full (no link)
+    def rooms
+      Hpricot(get.body).search("//h2/a").collect do |a|
+        Room.new(self, room_id_from_url(a.attributes['href']), a.inner_html)
+      end
+    end
+  
+    # Find a campfire room by name
+    def find_room_by_name(name)
+      rooms.detect {|room| room.name == name }
+    end
+
+    # Find a campfire room by its guest hash
+    def find_room_by_guest_hash(hash, name)
+      res = post(hash, :name => name)
+
+      Room.new(self, room_id_from_url(res['location'])) if verify_response(res, :redirect)
+    end
+    
+    # Creates and returns a new Room with the given +name+ and optionally a +topic+
+    def create_room(name, topic = nil)
+      find_room_by_name(name) if verify_response(post("account/create/room?from=lobby", {:room => {:name => name, :topic => topic}}, :ajax => true), :success)
+    end
+    
+    def find_or_create_room_by_name(name)
+      find_room_by_name(name) || create_room(name)
+    end
+    
+    # List the users that are currently chatting in any room
+    def users(*room_names)
+      users = Hpricot(get.body).search("div.room").collect do |room|
+        if room_names.empty? || room_names.include?((room/"h2/a").inner_html)
+          room.search("//li.user").collect { |user| user.inner_html }
+        end
+      end
+      users.flatten.compact.uniq.sort
+    end
+    
+    # Get the dates of the available transcripts by room
+    #
+    #   campfire.available_transcripts
+    #   #=> {"15840" => [#<Date: 4908311/2,0,2299161>, #<Date: 4908285/2,0,2299161>]}
+    #
+    def available_transcripts(room = nil)
+      url = "files%2Btranscripts"
+      url += "?room_id#{room}" if room
+      transcripts = (Hpricot(get(url).body) / ".transcript").inject({}) do |result,transcript|
+        link = (transcript / "a").first.attributes['href']
+        (result[room_id_from_url(link)] ||= []) << Date.parse(link.scan(/\/transcript\/(\d{4}\/\d{2}\/\d{2})/).to_s)
+        result
+      end
+      room ? transcripts[room.to_s] : transcripts
+    end
+    
+    # Is the connection to campfire using ssl?
+    def ssl?
+      uri.scheme == 'https'
+    end
+  
+  private
+  
+    def room_id_from_url(url)
+      url.scan(/room\/(\d*)/).to_s
+    end
+
+    def url_for(*args)
+      options = {:only_path => true}.merge(args.last.is_a?(Hash) ? args.pop : {})
+      path = args.shift
+      "#{options[:only_path] ? '' : uri}/#{path}"
+    end
+
+    def post(path, data = {}, options = {})
+      perform_request(options) do
+        returning Net::HTTP::Post.new(url_for(path)) do |request|
+          request.add_field 'Content-Type', 'application/x-www-form-urlencoded'
+          request.set_form_data flatten(data)
+        end
+      end
+    end
+    
+    def post_file(path, file_path, options = {})
+      agent = WWW::Mechanize.new
+      
+      agent.additional_headers = { 'User-Agent' => "Tinder/#{Tinder::VERSION::STRING} (http://tinder.rubyforge.org)" }
+      agent.additional_headers.merge!({ 'Cookie' => @cookie }) if @cookie
+      
+      node = Hpricot::Elem.new(Hpricot::STag.new('form'))
+      node['action']  = url_for(path, :only_path => false)
+      node['method']  = 'POST'
+      node['enctype'] = 'multipart/form-data'
+      
+      form = WWW::Mechanize::Form.new(node)
+      form.file_uploads << WWW::Mechanize::Form::FileUpload.new('upload', file_path)
+      
+      page = agent.submit(form)
+      return page.response
+    end
+  
+    def get(path = nil, options = {})
+      perform_request(options) { Net::HTTP::Get.new(url_for(path)) }
+    end
+  
+    def prepare_request(request, options = {})
+      returning request do
+        request.add_field 'User-Agent', "Tinder/#{Tinder::VERSION::STRING} (http://tinder.rubyforge.org)"
+        request.add_field 'Cookie', @cookie if @cookie
+        if options[:ajax]
+          request.add_field 'X-Requested-With', 'XMLHttpRequest'
+          request.add_field 'X-Prototype-Version', '1.5.1.1'
+        end
+      end
+    end
+    
+    def perform_request(options = {}, &block)
+      @request = prepare_request(yield, options)
+      http = @http.new(uri.host, uri.port)
+      http.use_ssl = ssl?
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if ssl?
+      @response = returning http.request(@request) do |response|
+        @cookie = response['set-cookie'] if response['set-cookie']
+      end
+    end
+  
+    # flatten a nested hash (:room => {:name => 'foobar'} to 'user[name]' => 'foobar')
+    def flatten(params)
+      params = params.dup
+      params.stringify_keys!.each do |k,v| 
+        if v.is_a? Hash
+          params.delete(k)
+          v.each {|subk,v| params["#{k}[#{subk}]"] = v }
+        end
+      end
+    end
+
+    def verify_response(response, options = {})
+      if options.is_a?(Symbol)
+        codes = case options
+        when :success; [200]
+        when :redirect; 300..399
+        else raise(ArgumentError, "Unknown response #{options}")
+        end
+        codes.include?(response.code.to_i)
+      elsif options[:redirect_to]
+        verify_response(response, :redirect) && response['location'] == options[:redirect_to]
+      else
+        false
+      end
+    end
+    
+  end
+end

data/lib/tinder/mechanize_ext.rb

@@ -0,0 +1,17 @@
+# from http://d.hatena.ne.jp/kitamomonga/20080720/ruby_mechanize_tadd_addtitional_header
+
+module WWW
+  class Mechanize
+    attr_accessor :additional_headers
+    alias :_set_headers :set_headers
+    def set_headers(uri, request, cur_page)
+      request = _set_headers(uri, request, cur_page)
+      if @additional_headers then
+        @additional_headers.each do |k, v|
+          (v ? request[k] = v : request.delete(k))
+        end
+      end
+      request
+    end
+  end
+end

data/lib/tinder/room.rb

@@ -0,0 +1,206 @@
+module Tinder
+  # A campfire room
+  class Room
+    attr_reader :id, :name
+
+    def initialize(campfire, id, name = nil)
+      @campfire = campfire
+      @id = id
+      @name = name
+    end
+    
+    # Join the room. Pass +true+ to join even if you've already joined.
+    def join(force = false)
+      @room = returning(get("room/#{id}")) do |room|
+        raise Error, "Could not join room" unless verify_response(room, :success)
+        @membership_key = room.body.scan(/\"membershipKey\": \"([a-z0-9]+)\"/).to_s
+        @user_id = room.body.scan(/\"userID\": (\d+)/).to_s
+        @last_cache_id = room.body.scan(/\"lastCacheID\": (\d+)/).to_s
+        @timestamp = room.body.scan(/\"timestamp\": (\d+)/).to_s
+        @idle_since = Time.now
+      end if @room.nil? || force
+      ping
+      true
+    end
+    
+    # Leave a room
+    def leave
+      returning verify_response(post("room/#{id}/leave"), :redirect) do
+        @room, @membership_key, @user_id, @last_cache_id, @timestamp, @idle_since = nil
+      end
+    end
+
+    # Toggle guest access on or off
+    def toggle_guest_access
+      # re-join the room to get the guest url
+      verify_response(post("room/#{id}/toggle_guest_access"), :success) && join(true)
+    end
+
+    # Get the url for guest access
+    def guest_url
+      join
+      link = (Hpricot(@room.body)/"#guest_access h4").first
+      link.inner_html if link
+    end
+    
+    def guest_access_enabled?
+      !guest_url.nil?
+    end
+
+    # The invite code use for guest
+    def guest_invite_code
+      guest_url.scan(/\/(\w*)$/).to_s
+    end
+
+    # Change the name of the room
+    def name=(name)
+      @name = name if verify_response(post("account/edit/room/#{id}", { :room => { :name => name }}, :ajax => true), :success)
+    end
+    alias_method :rename, :name=
+
+    # Change the topic
+    def topic=(topic)
+      topic if verify_response(post("room/#{id}/change_topic", { 'room' => { 'topic' => topic }}, :ajax => true), :success)
+    end
+    
+    # Get the current topic
+    def topic
+      join
+      h = (Hpricot(@room.body)/"#topic")
+      if h
+        (h/:span).remove
+        h.inner_text.strip
+      end
+    end
+    
+    # Lock the room to prevent new users from entering and to disable logging
+    def lock
+      verify_response(post("room/#{id}/lock", {}, :ajax => true), :success)
+    end
+
+    # Unlock the room
+    def unlock
+      verify_response(post("room/#{id}/unlock", {}, :ajax => true), :success)
+    end
+
+    def ping(force = false)
+      returning verify_response(post("room/#{id}/tabs", { }, :ajax => true), :success) do
+        @idle_since = Time.now
+      end if @idle_since < 1.minute.ago || force
+    end
+
+    def destroy
+      verify_response(post("account/delete/room/#{id}"), :success)
+    end
+
+    # Post a new message to the chat room
+    def speak(message, options = {})
+      message if verify_response(post("room/#{id}/speak", {:message => message,
+        :t => Time.now.to_i}.merge(options), :ajax => true), :success)
+    end
+
+    def paste(message)
+      speak message, :paste => true
+    end
+    
+    def upload(file_path)
+      post_file("upload.cgi/room/#{id}/uploads/new", file_path)
+    end
+    
+    # Get the list of users currently chatting for this room
+    def users
+      @campfire.users name
+    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"}]
+    #
+    # 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.
+    #
+    #   room.listen do |m|
+    #     room.speak "#{m[:person]}, Go away!" if m[:message] =~ /Java/i
+    #   end
+    #
+    def listen(interval = 5)
+      join
+      if block_given?
+        catch(:stop_listening) do
+          trap('INT') { throw :stop_listening }
+          loop do
+            ping
+            self.messages.each {|msg| yield msg }
+            sleep interval
+          end
+        end
+      else
+        self.messages
+      end
+    end
+    
+    # Get the dates for the available transcripts for this room
+    def available_transcripts
+      @campfire.available_transcripts(id)
+    end
+    
+    # Get the transcript for the given date (Returns a hash in the same format as #listen)
+    #
+    #   room.transcript(room.available_transcripts.first)
+    #   #=> [{:message=>"foobar!", :user_id=>"99999", :person=>"Brandon", :id=>"18659245"}]
+    #
+    def transcript(date)
+      (Hpricot(get("room/#{id}/transcript/#{date.to_date.strftime('%Y/%m/%d')}").body) / ".message").collect do |message|
+        person = (message / '.person span').first
+        body = (message / '.body div').first
+        {:id => message.attributes['id'].scan(/message_(\d+)/).to_s,
+          :person => person ? person.inner_html : nil,
+          :user_id => message.attributes['class'].scan(/user_(\d+)/).to_s,
+          :message => body ? body.inner_html : nil
+        }
+      end
+    end
+
+  protected
+    
+    def messages
+      returning [] do |messages|
+        response = post("poll.fcgi", {:l => @last_cache_id, :m => @membership_key,
+          :s => @timestamp, :t => "#{Time.now.to_i}000"}, :ajax => true)
+        if response.body.length > 1
+          lines = response.body.split("\r\n")
+          
+          if lines.length > 0
+            @last_cache_id = lines.pop.scan(/chat.poller.lastCacheID = (\d+)/).to_s
+            lines.each do |msg|
+              unless msg.match(/timestamp_message/)
+                if msg.length > 0
+                  messages << {
+                    :id => msg.scan(/message_(\d+)/).to_s,
+                    :user_id => msg.scan(/user_(\d+)/).to_s,
+                    :person => msg.scan(/\\u003Ctd class=\\"person\\"\\u003E(?:\\u003Cspan\\u003E)?(.+?)(?:\\u003C\/span\\u003E)?\\u003C\/td\\u003E/).to_s,
+                    :message => msg.scan(/\\u003Ctd class=\\"body\\"\\u003E\\u003Cdiv\\u003E(.+?)\\u003C\/div\\u003E\\u003C\/td\\u003E/).to_s
+                  }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  
+    [:post, :post_file, :get, :verify_response].each do |method|
+      define_method method do |*args|
+        @campfire.send method, *args
+      end
+    end
+
+  end
+end

data/lib/tinder/version.rb

@@ -0,0 +1,9 @@
+module Tinder #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 8
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/spec/campfire_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+context "Preparing a campfire request" do
+  setup do
+    @campfire = Tinder::Campfire.new("foobar")
+    @request = Net::HTTP::Get.new("does_not_matter")
+  end
+  
+  def prepare_request
+    @campfire.send(:prepare_request, @request)
+  end
+  
+  specify "should return the request" do
+    prepare_request.should equal(@request)
+  end
+
+  specify "should set the cookie" do
+    @campfire.instance_variable_set("@cookie", "foobar")
+    prepare_request['Cookie'].should == 'foobar'
+  end
+  
+  specify "should set the user agent" do
+    prepare_request['User-Agent'].should =~ /^Tinder/
+  end
+end
+
+# context "Performing a campfire request" do
+#   
+#   setup do
+#     @response = mock("response")
+#     Net::HTTP.any_instance.stubs(:request).returns(response)
+#     request = Net::HTTP::Get.new("does_not_matter")
+#     response.expects(:[]).with('set-cookie').and_return('foobar')
+#     @campfire.send(:perform_request) { request }
+#   end
+#   
+#   specify "should set cookie" do
+#     @campfire.instance_variable_get("@cookie").should == 'foobar'
+#   end
+#   
+# end
+
+context "Verifying a 200 response" do
+  
+  setup do
+    @campfire = Tinder::Campfire.new("foobar")
+    @response.should_receive(:code).and_return(200)
+  end
+  
+  specify "should return true when expecting success" do
+    @campfire.send(:verify_response, @response, :success).should equal(true)
+  end
+  
+  specify "should return false when expecting a redirect" do
+    @campfire.send(:verify_response, @response, :redirect).should equal(false)
+  end
+  
+  specify "should return false when expecting a redirect to a specific path" do
+    @campfire.send(:verify_response, @response, :redirect_to => '/foobar').should equal(false)
+  end
+  
+end
+
+context "Verifying a 302 response" do
+  
+  setup do
+    @campfire = Tinder::Campfire.new("foobar")
+    @response.should_receive(:code).and_return(302)
+  end
+  
+  specify "should return true when expecting redirect" do
+    @campfire.send(:verify_response, @response, :redirect).should equal(true)
+  end
+  
+  specify "should return false when expecting success" do
+    @campfire.send(:verify_response, @response, :success).should equal(false)
+  end
+  
+  specify "should return true when expecting a redirect to a specific path" do
+    @response.should_receive(:[]).with('location').and_return("/foobar")
+    @campfire.send(:verify_response, @response, :redirect_to => '/foobar').should equal(true)
+  end
+  
+  specify "should return false when redirecting to a different path than expected" do
+    @response.should_receive(:[]).with('location').and_return("/baz")
+    @campfire.send(:verify_response, @response, :redirect_to => '/foobar').should equal(false)
+  end
+
+end
+
+context "A failed login" do
+  
+  setup do
+    @campfire = Tinder::Campfire.new 'foobar'
+    @response = mock("response")
+    @campfire.should_receive(:post).and_return(@response)
+    @response.should_receive(:code).and_return("302")
+    @response.should_receive(:[]).with("location").and_return("/login")
+  end
+  
+  specify "should raise an error" do
+    lambda do
+      @campfire.login "doesn't", "matter"
+    end.should raise_error(Tinder::Error)
+  end
+  
+  specify "should not set logged in status" do
+    @campfire.login 'foo', 'bar' rescue
+    @campfire.logged_in?.should equal(false)
+  end
+  
+end
+
+context "Accessing a room with guest access" do
+
+  setup do
+    @room_id = 123
+    @campfire = Tinder::Campfire.new 'foobar'
+    @response = mock("response")
+    @campfire.stub!(:post).and_return(@response)
+  end
+
+  specify "should return a room for the public room" do
+    @response.should_receive(:code).and_return(302)
+    @response.should_receive(:[]).with("location").and_return("/rooms/#{@room_id}")
+
+    room = @campfire.find_room_by_guest_hash "valid_hash", "John Doe"
+    room.should be_kind_of(Tinder::Room)
+    room.campfire.should == @campfire
+    room.id.to_i.should == @room_id
+  end
+
+  specify "should raise an error if given an invalid room hash" do
+    @response.should_receive(:code).and_return(500)
+
+    room = @campfire.find_room_by_guest_hash "invalid_hash", "John Doe"
+    room.should be_nil
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/tinder.rb'

data/test/remote/remote_campfire_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RemoteCampfireTest < Test::Unit::TestCase
+  
+  def setup
+    # @subdomain = 'domain'
+    # @user, @pass = 'email@example.com', 'password'
+    @ssl = false
+    raise "Set your campfire credentials before running the remote tests" unless @user && @pass && @subdomain
+    @campfire = Tinder::Campfire.new @subdomain, :ssl => @ssl
+  end
+  
+  def test_ssl_required
+    if @ssl
+      campfire = Tinder::Campfire.new @subdomain
+      assert_raises(Tinder::SSLRequiredError) do
+        campfire.login(@user, @pass)
+      end
+    end
+  end
+  
+  def test_create_and_delete_room
+    assert login
+    assert @campfire.logged_in?
+    
+    room = @campfire.create_room("Testing#{Time.now.to_i}")
+    
+    assert_instance_of Tinder::Room, room
+    assert_not_nil room.id
+    
+    room.name = "new name"
+    assert_equal "new name", room.name
+    
+    room.destroy
+    assert_nil @campfire.find_room_by_name(room.name)
+    
+    assert @campfire.logout
+  ensure
+    room.destroy rescue nil
+  end
+  
+  def test_failed_login
+    assert_raises(Tinder::Error) { @campfire.login(@user, 'notmypassword') }
+    assert !@campfire.logged_in?
+  end
+  
+  def test_find_nonexistent_room
+    login
+    assert_nil @campfire.find_room_by_name('No Room Should Have This Name')
+  end
+
+private
+
+  def login(user = @user, pass = @pass)
+    @campfire.login(user, pass)
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__) + '/mocks')
+require 'test/unit'
+require 'rubygems'
+require 'active_support'
+require File.dirname(__FILE__) + '/../lib/tinder.rb'
+require 'mocha'
+require 'stubba'

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: timriley-tinder
+version: !ruby/object:Gem::Version 
+  version: 1.1.9
+platform: ruby
+authors: 
+- Brandon Keepers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: This is a fork of Tinder with file upload support.
+email: brandon@opensoul.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG.txt
+- Manifest.txt
+- README.txt
+files: 
+- CHANGELOG.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- init.rb
+- lib/tinder.rb
+- lib/tinder/campfire.rb
+- lib/tinder/room.rb
+- lib/tinder/version.rb
+- lib/tinder/mechanize_ext.rb
+has_rdoc: true
+homepage: http://github.com/timriley/tinder
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An API for interfacing with Campfire, the 37Signals chat application.
+test_files: 
+- test/test_helper.rb
+- test/remote/remote_campfire_test.rb
+- spec/campfire_spec.rb
+- spec/spec_helper.rb