collectiveidea-tinder 1.2.2

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+rdoc
+test/remote/credentials.rb

data/CHANGELOG.txt

@@ -0,0 +1,39 @@
+1.2.1 - 2009-08-27
+* Fixes for listening after campfire updates [Jordan Byron]
+
+1.2.0 - 2009-01-28
+* Get the list of available files [Christopher MacGown]
+* Upload files [Joshua Wand]
+* Find rooms even when full [Josh Owens]
+* Join rooms as a guest [Ian Lesperance]
+
+1.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,10 @@
+CHANGELOG.txt
+Manifest.txt
+README.txt
+Rakefile
+init.rb
+lib/tinder.rb
+lib/tinder/campfire.rb
+lib/tinder/multipart.rb
+lib/tinder/room.rb
+lib/tinder/version.rb

data/README.txt

@@ -0,0 +1,48 @@
+= Tinder - get the Campfire started
+
+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.
+
+== Installation
+
+Tinder can be installed as a gem or a Rails plugin:
+
+  gem install tinder
+  
+  script/plugin install git://github.com/collectiveidea/tinder.git
+  
+== How to contribute
+
+If you find what looks like a bug:
+
+1. Check the GitHub issue tracker to see if anyone else has had the same issue.
+   http://github.com/collectiveidea/tinder/issues/
+2. If you don't see anything, create an issue with information on how to reproduce it.
+
+If you want to contribute an enhancement or a fix:
+
+1. Fork the project on github.
+   http://github.com/collectiveidea/tinder
+2. Make your changes with tests.
+3. Commit the changes without making changes to the Rakefile, VERSION, or any other files that aren't related to your enhancement or fix
+4. Send a pull request.
+
+== ToDo
+
+* Tests! (unit and remote)
+* Marshmallow-style integration scripts for exception notification and continuous integration

data/Rakefile

@@ -0,0 +1,68 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "tinder"
+    gem.summary = "An (unofficial) Campfire API"
+    gem.description = "An API for interfacing with Campfire, the 37Signals chat application."
+    gem.authors = ['Brandon Keepers']
+    gem.email = 'brandon@opensoul.org'
+    gem.homepage = 'http://github.com/collectiveidea/tinder'
+    gem.rubyforge_project = "tinder"
+    gem.add_dependency "activesupport"
+    gem.add_dependency "hpricot"
+    gem.add_dependency "mime-types"
+    gem.add_development_dependency "rspec"
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tinder #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'spec/rake/spectask'
+desc "Run the specs under spec"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run tests"
+task :default => [:spec, :test]

data/VERSION

@@ -0,0 +1 @@
+1.2.2

data/init.rb

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

data/lib/tinder.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'active_support'
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'open-uri'
+require 'hpricot'
+
+require 'tinder/multipart'
+require 'tinder/campfire'
+require 'tinder/room'
+
+module Tinder
+  class Error < StandardError; end
+  class SSLRequiredError < Error; end
+end

data/lib/tinder/campfire.rb

@@ -0,0 +1,207 @@
+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("//div.room").collect do |a|
+        name = a.search("//h2/a").inner_html.strip
+        name = a.search("//h2").inner_html.strip if name.empty?
+        Room.new(self, room_id_from_element(a.attributes['id']), name)
+      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 room_id_from_element(element)
+      element.split("_").last
+    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|
+          if options[:multipart]
+            request.body = data
+          else
+            request.set_form_data(flatten(data))
+          end
+        end
+      end
+    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 (http://tinder.rubyforge.org)"
+        request.add_field 'Cookie', @cookie if @cookie
+        request.add_field 'X-Requested-With', 'XMLHttpRequest'
+        if options[:ajax]
+          request.add_field 'X-Prototype-Version', '1.5.1.1'
+        end
+        if options[:multipart]
+          request.add_field 'Content-Type', 'multipart/form-data, boundary=' + Multipart::MultipartPost::BOUNDARY + " "
+        else
+          request.add_field 'Content-Type', 'application/x-www-form-urlencoded'
+        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/multipart.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'mime/types'
+require 'net/http'
+require 'cgi'
+
+module Multipart #:nodoc:
+  # From: http://deftcode.com/code/flickr_upload/multipartpost.rb
+  ## Helper class to prepare an HTTP POST request with a file upload
+  ## Mostly taken from
+  #http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/113774
+  ### WAS:
+  ## Anything that's broken and wrong probably the fault of Bill Stilwell
+  ##(bill@marginalia.org)
+  ### NOW:
+  ## Everything wrong is due to keith@oreilly.com
+
+  class Param #:nodoc:
+    attr_accessor :k, :v
+    def initialize(k, v)
+      @k = k
+      @v = v
+    end
+
+    def to_multipart
+      "Content-Disposition: form-data; name=\"#{k}\"\r\n\r\n#{v}\r\n"
+    end
+  end
+
+  class FileParam #:nodoc:
+    attr_accessor :k, :filename, :content
+    def initialize(k, filename, content)
+      @k = k
+      @filename = filename
+      @content = content
+    end
+
+    def to_multipart
+      "Content-Disposition: form-data; name=\"#{k}\"; filename=\"#{filename}\"\r\n" +
+        "Content-Transfer-Encoding: binary\r\n" +
+        "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" +
+        @content + "\r\n"
+    end
+  end
+  
+  class MultipartPost #:nodoc:
+    BOUNDARY = 'campfire-is-awesome'
+    HEADER = {"Content-type" => "multipart/form-data, boundary=" + BOUNDARY + " "}
+    TIMEOUT_SECONDS = 30
+
+    attr_accessor :params, :query, :headers
+    def initialize(params)
+      @params = params
+      @query = {}
+      self.prepare_query
+    end
+
+    def prepare_query()
+      @query = @params.map do |k,v|
+        param = v.respond_to?(:read) ? FileParam.new(k, v.path, v.read) : Param.new(k, v)
+        "--#{BOUNDARY}\r\n#{param.to_multipart}"
+      end.join("") + "--#{BOUNDARY}--"
+    end
+  end
+end