messenger 0.2.0 → 0.3.0

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "messenger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+    test.rcov_opts << '--exclude "gems/*"'
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install rcov"
+  end
+end

data/bin/messenger

@@ -95,7 +95,7 @@ end
 #
 puts "# Sending message to #{ARGV[0]}"
 begin
-  result = Messenger.send(ARGV[0], ARGV[1], options)
+  result = Messenger.deliver(ARGV[0], ARGV[1], options)
   if result.success?
     puts "# Message sent successfully"
   else

data/lib/messenger.rb

@@ -1,76 +1,9 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'rubygems'
 require 'messenger/errors'
-require 'system_timer'
-
-
-module Messenger
-
-  MESSAGER_VERSION = [0,1] unless defined?(MESSAGER_VERSION)
-  APP_ROOT = File.expand_path(File.dirname(__FILE__) + '/..') unless defined?(APP_ROOT)
-
-  def self.version
-    MESSAGER_VERSION.join(".")
-  end
-
-  def self.root
-    APP_ROOT
-  end
-
-
-  def self.valid_url?(url)
-    service_handler = handler(url)
-    service_handler.valid_url?(url)
-  rescue ProtocolError
-    false
-  end
-
-  def self.send(url, message, options={})
-    service_handler = handler(url)
-    SystemTimer.timeout_after(options[:timeout] || 15) do
-      service_handler.send(url, message, options)
-    end
-  end
-
-  def self.obfuscate(url)
-    service_handler = handler(url)
-    service_handler.obfuscate(url)
-  end
-
-
-  def self.protocol(url)
-    # TODO: More services
-    #   sms://1231231234
-    #   twitter://username
-    #   aim://username
-    case url
-    when /^http/:      :http
-    when /^campfire/:  :campfire
-    when /^jabber/:    :jabber
-    when /^notifo/:    :notifo
-    when /^mailto|@+/: :email
-    end
-  end
-
-  def self.handler(url)
-    case protocol(url)
-    when :email:    Email
-    when :http:     Web
-    when :campfire: Campfire
-    when :jabber:   Jabber
-    when :notifo:   Notifo
-    else
-      raise ProtocolError, "Malformed service URL: #{url}. Either this syntax is wrong or this service type is not yet implemented."
-    end
-  end
-
-
-  autoload :Result, "messenger/result"
-  autoload :Email, "messenger/email"
-  autoload :Web, "messenger/web"
-  autoload :Campfire, "messenger/campfire"
-  autoload :Jabber, "messenger/jabber"
-  autoload :Notifo, "messenger/notifo"
-
-end
+require 'messenger/messenger'
+require 'messenger/result'
+require 'messenger/email'
+require 'messenger/web'
+require 'messenger/campfire'
+require 'messenger/jabber'
+require 'messenger/notifo'
+require 'messenger/version'

data/lib/messenger/campfire.rb

@@ -1,51 +1,47 @@
-require 'httparty'
+require 'typhoeus'
 require 'json'
 
-module Messenger
+class Messenger::Campfire
 
-  class Campfire
-
-    def self.valid_url?(url)
-      !!matcher(url)
-    rescue NoMethodError
-      false
-    end
+  def self.valid_url?(url)
+    !!matcher(url)
+  rescue NoMethodError
+    false
+  end
 
-    # URL format:
-    #     campfire://api-key:room-id@subdomain.campfirenow.com
-    def self.send(url, body, options={})
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      ssl, api_key, room, subdomain = matcher(url)
-      response = HTTParty.post(
-        "http#{ssl ? "s" : ""}://#{subdomain}.campfirenow.com/room/#{room}/speak.json",
-        :basic_auth => { :username => api_key, :password => "x" },
-        :headers => { "Content-Type" => "application/json" },
-        :body => { "message" => { "body" => body } }.to_json
-      )
-      Result.new(success?(response), response)
-    end
+  # URL format:
+  #     campfire://api-key:room-id@subdomain.campfirenow.com
+  def self.deliver(url, body, options={})
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    ssl, api_key, room, subdomain = matcher(url)
+    options[:headers] ||= {}
+    response = Typhoeus::Request.post(
+      "http#{ssl ? "s" : ""}://#{api_key}:x@#{subdomain}.campfirenow.com/room/#{room}/speak.json",
+      :headers => { "Content-Type" => "application/json"}.merge(options[:headers]),
+      :body => { "message" => { "body" => body } }.to_json
+    )
+    Messenger::Result.new(success?(response), response)
+  end
 
-    def self.obfuscate(url)
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      ssl, api_key, room, subdomain = matcher(url)
-      "campfire#{ssl ? "-ssl" : ""}://xxxx:#{room}@#{subdomain}.campfirenow.com"
-    end
+  def self.obfuscate(url)
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    ssl, api_key, room, subdomain = matcher(url)
+    "campfire#{ssl ? "-ssl" : ""}://xxxx:#{room}@#{subdomain}.campfirenow.com"
+  end
 
 
-  private
+private
 
-    def self.matcher(url)
-      url.match(/^campfire(-ssl)?:\/\/([^:]+):([^@]+)@([^\.]+).campfirenow.com/)[1,4]
-    end
+  def self.matcher(url)
+    url.match(/^campfire(-ssl)?:\/\/([^:]+):([^@]+)@([^\.]+).campfirenow.com/)[1,4]
+  end
 
-    def self.success?(response)
-      case response.code
-      when 200, 201: true
-      else
-        false
-      end
+  def self.success?(response)
+    case response.code
+    when 200, 201: true
+    else
+      false
     end
-
   end
 
 end

data/lib/messenger/email.rb

@@ -1,38 +1,34 @@
 require 'mail'
 
-module Messenger
+class Messenger::Email
 
-  class Email
-
-    def self.valid_url?(url)
-      !!url.match(/^(mailto:)?[^@]+@.*$/)
-    end
-
-    # URL format:
-    #     mailto:email@example.com
-    #
-    # Options:
-    #     :email_from => Who the email is from
-    #     :email_subject => The subject of the email
-    def self.send(url, message, options={})
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      mail = Mail.new do
-            from options[:email_from]
-              to url.sub(/mailto:/, '')
-         subject options[:email_subject]
-            body message
-      end
-      mail.deliver!
-      Result.new(true, nil)
-    rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT => e
-      Result.new(false, e)
-    end
+  def self.valid_url?(url)
+    !!url.match(/^(mailto:)?[^@]+@.*$/)
+  end
 
-    def self.obfuscate(url)
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      url
+  # URL format:
+  #     mailto:email@example.com
+  #
+  # Options:
+  #     :email_from => Who the email is from
+  #     :email_subject => The subject of the email
+  def self.deliver(url, message, options={})
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    mail = Mail.new do
+          from options[:email_from]
+            to url.sub(/mailto:/, '')
+       subject options[:email_subject]
+          body message
     end
+    mail.deliver!
+    Messenger::Result.new(true, nil)
+  rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT => e
+    Messenger::Result.new(false, e)
+  end
 
+  def self.obfuscate(url)
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    url
   end
 
 end

data/lib/messenger/jabber.rb

@@ -1,49 +1,45 @@
 require 'xmpp4r-simple'
 
-module Messenger
+module Messenger::Jabber
 
-  class Jabber
-
-    def self.valid_url?(url)
-      !!matcher(url)
-    rescue NoMethodError
-      false
-    end
-
-    # URL format:
-    #     jabber://email@example.com/server_hostname
-    #
-    # The server's hostname is optional, but needed for Google Apps jabber accounts.
-    #
-    # Options:
-    #     :jabber_id => The jabber id of the sender
-    #     :jabber_password => The password of the sender
-    def self.send(url, body, options={})
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      recipient, host = url.sub("jabber://", "").split("/")[0,2]
-      jabber = ::Jabber::Simple.new(options[:jabber_id], options[:jabber_password], host)
-      jabber.deliver(recipient, body)
-      pending_messages_count = 1
-      until pending_messages_count == 0
-        pending_messages_count = jabber.send(:queue, :pending_messages).size
-        sleep 1
-      end
-      status = jabber.subscribed_to?(recipient)
-      Result.new(status, status ? nil : "Not yet authorized")
-    end
+  def self.valid_url?(url)
+    !!matcher(url)
+  rescue NoMethodError
+    false
+  end
 
-    def self.obfuscate(url)
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      url
+  # URL format:
+  #     jabber://email@example.com/server_hostname
+  #
+  # The server's hostname is optional, but needed for Google Apps jabber accounts.
+  #
+  # Options:
+  #     :jabber_id => The jabber id of the sender
+  #     :jabber_password => The password of the sender
+  def self.deliver(url, body, options={})
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    recipient, host = url.sub("jabber://", "").split("/")[0,2]
+    jabber = ::Jabber::Simple.new(options[:jabber_id], options[:jabber_password], host)
+    jabber.deliver(recipient, body)
+    pending_messages_count = 1
+    until pending_messages_count == 0
+      pending_messages_count = jabber.send(:queue, :pending_messages).size
+      sleep 1
     end
+    status = jabber.subscribed_to?(recipient)
+    Messenger::Result.new(status, status ? nil : "Not yet authorized")
+  end
 
+  def self.obfuscate(url)
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    url
+  end
 
-  private
 
-    def self.matcher(url)
-      url.sub("jabber://", "").match("@")
-    end
+private
 
+  def self.matcher(url)
+    url.sub("jabber://", "").match("@")
   end
 
 end

data/lib/messenger/messenger.rb

@@ -0,0 +1,69 @@
+require 'system_timer'
+require 'base64'
+
+module Messenger
+
+  MESSAGER_VERSION = [0,1] unless defined?(MESSAGER_VERSION)
+  APP_ROOT = File.expand_path(File.dirname(__FILE__) + '/..') unless defined?(APP_ROOT)
+
+  def self.version
+    MESSAGER_VERSION.join(".")
+  end
+
+  def self.root
+    APP_ROOT
+  end
+
+
+  def self.valid_url?(url)
+    service_handler = handler(url)
+    service_handler.valid_url?(url)
+  rescue ProtocolError
+    false
+  end
+
+  def self.deliver(url, message, options={})
+    service_handler = handler(url)
+    SystemTimer.timeout_after(options[:timeout] || 15) do
+      service_handler.deliver(url, message, options)
+    end
+  end
+
+  def self.obfuscate(url)
+    service_handler = handler(url)
+    service_handler.obfuscate(url)
+  end
+
+
+  def self.protocol(url)
+    # TODO: More services
+    #   sms://1231231234
+    #   twitter://username
+    #   aim://username
+    case url
+    when /^http/:      :http
+    when /^campfire/:  :campfire
+    when /^jabber/:    :jabber
+    when /^notifo/:    :notifo
+    when /^mailto|@+/: :email
+    end
+  end
+
+  def self.handler(url)
+    case protocol(url)
+    when :email:    Messenger::Email
+    when :http:     Messenger::Web
+    when :campfire: Messenger::Campfire
+    when :jabber:   Messenger::Jabber
+    when :notifo:   Messenger::Notifo
+    else
+      raise Messenger::ProtocolError, "Malformed service URL: #{url}. Either this syntax is wrong or this service type is not yet implemented."
+    end
+  end
+
+  def self.basic_auth(user, password)
+    encoded_credentials = ["#{user}:#{password}"].pack("m*").gsub(/\n/, '')
+    {"HTTP_AUTHORIZATION" => "Basic #{encoded_credentials}"}
+  end
+
+end

data/lib/messenger/notifo.rb

@@ -1,47 +1,42 @@
-require 'httparty'
+require 'typhoeus'
 require 'json'
 
-module Messenger
+class Messenger::Notifo
 
-  class Notifo
-
-    def self.valid_url?(url)
-      !!url.match(/^notifo:\/\/.+$/)
-    end
-
-    # URL format:
-    #     notifo://username
-    #
-    # Options:
-    #     :notifo_api_username => The service's API username
-    #     :notifo_api_secret => The service's API secret
-    #     :notifo_title => The notificaiton title
-    #     :notifo_url => Open this URL
-    def self.send(url, message, options={})
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      username = matcher(url)
-      response = HTTParty.post("https://api.notifo.com/v1/send_notification",
-                   :body => { :to => username, :msg => message, :title => options[:notifo_title], :uri => options[:notifo_url] },
-                   :basic_auth => { :username => options[:notifo_api_username], :password => options[:notifo_api_secret] })
-      Result.new(success?(response), response)
-    end
+  def self.valid_url?(url)
+    !!url.match(/^notifo:\/\/.+$/)
+  end
 
-    def self.obfuscate(url)
-      raise URLError, "The URL provided is invalid" unless valid_url?(url)
-      url
-    end
+  # URL format:
+  #     notifo://username
+  #
+  # Options:
+  #     :notifo_api_username => The service's API username
+  #     :notifo_api_secret => The service's API secret
+  #     :notifo_title => The notificaiton title
+  #     :notifo_url => Open this URL
+  def self.deliver(url, message, options={})
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    username = matcher(url)
+    response = Typhoeus::Request.post("https://#{options[:notifo_api_username]}:#{options[:notifo_api_secret]}@api.notifo.com/v1/send_notification",
+                                      :body => { :to => username, :msg => message, :title => options[:notifo_title], :uri => options[:notifo_url] }.to_param)
+    Messenger::Result.new(success?(response), response)
+  end
 
+  def self.obfuscate(url)
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    url
+  end
 
-  private
 
-    def self.matcher(url)
-      url.match(/^notifo:\/\/(.+)/)[1]
-    end
+private
 
-    def self.success?(response)
-      response.code == 200
-    end
+  def self.matcher(url)
+    url.match(/^notifo:\/\/(.+)/)[1]
+  end
 
+  def self.success?(response)
+    response.code == 200
   end
 
 end

data/lib/messenger/result.rb

@@ -1,30 +1,26 @@
-module Messenger
+class Messenger::Result
 
-  class Result
+  attr_reader :response
 
-    attr_reader :response
-
-    def initialize(success, response)
-      @success = success
-      @response = response
-    end
+  def initialize(success, response)
+    @success = success
+    @response = response
+  end
 
-    def success?
-      !!@success
-    end
+  def success?
+    !!@success
+  end
 
-    def code
-      response.code rescue nil
-    end
+  def code
+    response.code rescue nil
+  end
 
-    def body
-      if response.respond_to?(:body)
-        response.body
-      else
-        response.to_s
-      end
+  def body
+    if response.respond_to?(:body)
+      response.body
+    else
+      response.to_s
     end
-
   end
 
 end

data/lib/messenger/version.rb

@@ -0,0 +1,3 @@
+module Messenger
+  VERSION = '0.3.0'
+end

data/lib/messenger/web.rb

@@ -1,47 +1,43 @@
-require 'httparty'
+require 'typhoeus'
 
-module Messenger
+class Messenger::Web
 
-  class Web
-
-    def self.valid_url?(url)
-      !!URI.parse(url)
-    rescue URI::InvalidURIError
-      false
-    end
+  def self.valid_url?(url)
+    !!URI.parse(url)
+  rescue URI::InvalidURIError
+    false
+  end
 
-    # URL format:
-    #     http://example.com
-    #     https://user:pass@example.com
-    #
-    # The body of the message is posted as the body of the request, not the query.
-    def self.send(url, body, options={})
-      raise URLError, "The URL provided is invalid" unless self.valid_url?(url)
-      response = HTTParty.post(url, options.merge(:body => body))
-      Result.new(success?(response), response)
-    end
+  # URL format:
+  #     http://example.com
+  #     https://user:pass@example.com
+  #
+  # The body of the message is posted as the body of the request, not the query.
+  def self.deliver(url, body, options={})
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    response = Typhoeus::Request.post(url, options.merge(:body => body))
+    Messenger::Result.new(success?(response), response)
+  end
 
-    def self.obfuscate(url)
-      raise URLError, "The URL provided is invalid" unless self.valid_url?(url)
-      path = URI.parse(url)
-      if path.password
-        url.sub(/#{path.password}/, 'xxxx')
-      else
-        url
-      end
+  def self.obfuscate(url)
+    raise Messenger::URLError, "The URL provided is invalid" unless valid_url?(url)
+    path = URI.parse(url)
+    if path.password
+      url.sub(/#{path.password}/, 'xxxx')
+    else
+      url
     end
+  end
 
 
-  private
+private
 
-    def self.success?(response)
-      case response.code
-      when 200, 201: true
-      else
-        false
-      end
+  def self.success?(response)
+    case response.code
+    when 200, 201: true
+    else
+      false
     end
-
   end
 
 end

metadata

@@ -1,150 +1,121 @@
 --- !ruby/object:Gem::Specification 
 name: messenger
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Brandon Arbini
+- Nathan Sutton
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-06-17 00:00:00 -05:00
-default_executable: messenger
+date: 2010-06-22 00:00:00 -05:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: trollop
+  name: SystemTimer
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 17
         segments: 
-        - 1
-        - 15
-        version: "1.15"
+        - 0
+        version: "0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: mime-types
+  name: xmpp4r-simple
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 47
         segments: 
-        - 1
-        - 16
-        version: "1.16"
+        - 0
+        version: "0"
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: httparty
+  name: mail
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
         segments: 
         - 0
-        - 5
-        - 2
-        version: 0.5.2
+        version: "0"
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: SystemTimer
+  name: typhoeus
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 21
         segments: 
-        - 1
-        - 1
-        - 3
-        version: 1.1.3
+        - 0
+        version: "0"
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: xmpp4r
+  name: trollop
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 1
         segments: 
         - 0
-        - 5
-        version: "0.5"
+        version: "0"
   type: :runtime
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: xmpp4r-simple
+  name: shoulda
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 47
         segments: 
         - 0
-        - 8
-        - 8
-        version: 0.8.8
-  type: :runtime
+        version: "0"
+  type: :development
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: json_pure
+  name: mocha
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
         segments: 
-        - 1
-        - 2
         - 0
-        version: 1.2.0
-  type: :runtime
+        version: "0"
+  type: :development
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
-  name: mail
+  name: webmock
   prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
         segments: 
-        - 2
-        - 1
-        - 2
-        version: 2.1.2
-  type: :runtime
+        - 0
+        version: "0"
+  type: :development
   version_requirements: *id008
-description: "Messenger: easy message sending"
-email: brandon@zencoder.tv
+description: "Messenger: easy message sending for various protocols."
+email: brandon@zencoder.com
 executables: 
 - messenger
 extensions: []
@@ -153,66 +124,48 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files: 
-- README.markdown
-- VERSION.yml
-- lib/messenger.rb
 - lib/messenger/campfire.rb
 - lib/messenger/email.rb
 - lib/messenger/errors.rb
 - lib/messenger/jabber.rb
+- lib/messenger/messenger.rb
 - lib/messenger/notifo.rb
 - lib/messenger/result.rb
+- lib/messenger/version.rb
 - lib/messenger/web.rb
-- test/test_campfire.rb
-- test/test_email.rb
-- test/test_helper.rb
-- test/test_jabber.rb
-- test/test_messenger.rb
-- test/test_notifo.rb
-- test/test_result.rb
-- test/test_web.rb
+- lib/messenger.rb
 - LICENSE
-- bin/messenger
+- README.markdown
+- Rakefile
 has_rdoc: true
 homepage: http://github.com/zencoder/messenger
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubyforge_project: messenger
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: "Messenger: easy message sending"
-test_files: 
-- test/test_campfire.rb
-- test/test_email.rb
-- test/test_helper.rb
-- test/test_jabber.rb
-- test/test_messenger.rb
-- test/test_notifo.rb
-- test/test_result.rb
-- test/test_web.rb
+test_files: []
+

data/VERSION.yml

@@ -1,5 +0,0 @@
---- 
-:minor: 2
-:build: 
-:patch: 0
-:major: 0

data/test/test_campfire.rb

@@ -1,73 +0,0 @@
-require "test_helper"
-require 'httparty'
-
-module Messenger
-
-  class CampfireTest < Test::Unit::TestCase
-
-    context "Campfire notification" do
-      setup do
-        @success_response = stub(:code => 200)
-        @failure_response = stub(:code => 500)
-      end
-
-      should "post a successful message" do
-        HTTParty.expects(:post).with("http://subdomain.campfirenow.com/room/room/speak.json", :basic_auth => { :username => 'api', :password => 'x' }, :body => '{"message":{"body":"content"}}', :headers => { "Content-Type" => "application/json" }).returns(@success_response)
-        result = Campfire.send("campfire://api:room@subdomain.campfirenow.com", 'content')
-        assert result.success?
-        assert_equal @success_response, result.response
-      end
-
-      should "post to secure URL" do
-        HTTParty.expects(:post).with("https://subdomain.campfirenow.com/room/room/speak.json", :basic_auth => { :username => 'api', :password => 'x' }, :body => '{"message":{"body":"content"}}', :headers => { "Content-Type" => "application/json" }).returns(@success_response)
-        result = Campfire.send("campfire-ssl://api:room@subdomain.campfirenow.com", 'content')
-        assert result.success?
-        assert_equal @success_response, result.response
-      end
-
-      should "post a failed message" do
-        HTTParty.expects(:post).with("http://subdomain.campfirenow.com/room/room/speak.json", :basic_auth => { :username => 'api', :password => 'x' }, :body => '{"message":{"body":"content"}}', :headers => { "Content-Type" => "application/json" }).returns(@failure_response)
-        result = Campfire.send("campfire://api:room@subdomain.campfirenow.com", 'content')
-        assert_equal false, result.success?
-        assert_equal @failure_response, result.response
-      end
-
-      should "raise when sending to an invalid URL" do
-        assert_raises URLError do
-          Campfire.send("campfire://missing_room@subdomain.campfirenow.com", 'content')
-        end
-      end
-
-      should "obfuscate the URL" do
-        assert_equal "campfire://xxxx:1234@example.campfirenow.com", Campfire.obfuscate("campfire://asdf1234:1234@example.campfirenow.com")
-      end
-
-      should "obfuscate a secure URL" do
-        assert_equal "campfire-ssl://xxxx:1234@example.campfirenow.com", Campfire.obfuscate("campfire-ssl://asdf1234:1234@example.campfirenow.com")
-      end
-
-      should "raise when obfuscating an invalid URL" do
-        assert_raises URLError do
-          Campfire.obfuscate("campfire://missing_room@subdomain.campfirenow.com")
-        end
-      end
-    end
-
-    context "Campfire URL validation" do
-      should "return true for good URLs" do
-        assert true, Campfire.valid_url?("campfire://api_key:room@subdomain.campfirenow.com")
-        assert true, Campfire.valid_url?("campfire-ssl://api_key:room@subdomain.campfirenow.com")
-      end
-
-      should "return false for bad URLs" do
-        assert_equal false, Campfire.valid_url?("campfire://!")
-        assert_equal false, Campfire.valid_url?("campfire://api_key@subdomain.campfirenow.com")
-        assert_equal false, Campfire.valid_url?("campfire://:room@subdomain.campfirenow.com")
-        assert_equal false, Campfire.valid_url?("campfire://api_key:room@subdomain")
-        assert_equal false, Campfire.valid_url?("campfire://api_key:room@campfirenow.com")
-      end
-    end
-
-  end
-
-end

data/test/test_email.rb

@@ -1,55 +0,0 @@
-require "test_helper"
-require 'mail'
-
-module Messenger
-
-  class EmailTest < Test::Unit::TestCase
-
-    context "Email notification" do
-      setup do
-        Mail.defaults do
-          delivery_method :test
-        end
-      end
-
-      should "send an email" do
-        Email.send("mailto:to_test@example.com", "Test message", :email_from => "from_test@example.com", :email_subject => "Test")
-        assert_equal 1, Mail::TestMailer.deliveries.length
-        assert_equal ["to_test@example.com"], Mail::TestMailer.deliveries.first.to
-        assert_equal ["from_test@example.com"], Mail::TestMailer.deliveries.first.from
-        assert_equal "Test", Mail::TestMailer.deliveries.first.subject
-        assert_equal "Test message", Mail::TestMailer.deliveries.first.body.to_s
-      end
-
-      should "raise if trying to send to an invalid URL" do
-        assert_raises URLError do
-          Email.send("mailto:test", :body => "whatever", :email_from => "from_test@example.com", :email_subject => "Test")
-        end
-      end
-
-      should "obfuscate the URL" do
-        assert_equal "mailto:test@example.com", Email.obfuscate("mailto:test@example.com")
-      end
-
-      should "raise if trying obfuscate an invalid URL" do
-        assert_raises URLError do
-          Email.obfuscate("mailto:test")
-        end
-      end
-    end
-
-    context "Email notificaiton URL validation" do
-      should "return true for good URLs" do
-        assert true, Email.valid_url?("mailto:test@example.com")
-      end
-
-      should "return false for bad URLs" do
-        assert_equal false, Email.valid_url?("mailto:")
-        assert_equal false, Email.valid_url?("mailto:test")
-        assert_equal false, Email.valid_url?("mailto:example.com")
-      end
-    end
-
-  end
-
-end

data/test/test_helper.rb

@@ -1,11 +0,0 @@
-require "messenger"
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-require 'webmock/test_unit'
-
-class Test::Unit::TestCase
-  include WebMock
-end
-
-Dir["#{File.dirname(__FILE__)}/shoulda_macros/*.rb"].each {|file| require file }

data/test/test_jabber.rb

@@ -1,66 +0,0 @@
-require "test_helper"
-require 'xmpp4r-simple'
-
-module Messenger
-
-  class JabberTest < Test::Unit::TestCase
-
-    context "Jabber notification" do
-      setup do
-        @successful_jabber = stub("jabber", :deliver => nil, :queue => stub("queue", :size => 0), :subscribed_to? => true)
-        @failed_jabber = stub("jabber", :deliver => nil, :queue => stub("queue", :size => 0), :subscribed_to? => false)
-      end
-
-      should "send a successful jabber message" do
-        ::Jabber::Simple.expects(:new).with("notifier@zencoder.com", "asdfasdf", nil).returns(@successful_jabber)
-        result = Jabber.send("jabber://brandon@zencoder.com", "Test message", :jabber_id => "notifier@zencoder.com", :jabber_password => "asdfasdf")
-        assert result.success?
-        assert_nil result.response
-      end
-
-      should "determine and set the jabber host" do
-        ::Jabber::Simple.expects(:new).with("notifier@zencoder.com", "asdfasdf", "host.com").returns(@successful_jabber)
-        result = Jabber.send("jabber://brandon@zencoder.com/host.com", "Test message", :jabber_id => "notifier@zencoder.com", :jabber_password => "asdfasdf")
-        assert result.success?
-        assert_nil result.response
-      end
-
-      should "fail if the recipient is not subscribed" do
-        ::Jabber::Simple.expects(:new).with("notifier@zencoder.com", "asdfasdf", nil).returns(@failed_jabber)
-        result = Jabber.send("jabber://brandon@zencoder.com", "Test message", :jabber_id => "notifier@zencoder.com", :jabber_password => "asdfasdf")
-        assert_equal false, result.success?
-        assert_equal "Not yet authorized", result.response
-      end
-
-      should "raise when sending to an invalid URL" do
-        assert_raises URLError do
-          Jabber.send("jabber://", :jabber_id => "asdf", :jabber_password => "asdf")
-        end
-      end
-
-      should "obfuscate the URL" do
-        assert_equal "jabber://test@example.com", Jabber.obfuscate("jabber://test@example.com")
-      end
-
-      should "raise when obfuscating an invalid URL" do
-        assert_raises URLError do
-          Jabber.obfuscate("jabber://")
-        end
-      end
-    end
-
-    context "Jabber URL validation" do
-      should "return true for good URLs" do
-        assert true, Jabber.valid_url?("jabber://test@example.com")
-      end
-
-      should "return false for bad URLs" do
-        assert_equal false, Jabber.valid_url?("jabber://!")
-        assert_equal false, Jabber.valid_url?("jabber://test")
-        assert_equal false, Jabber.valid_url?("jabber://example.com")
-      end
-    end
-
-  end
-
-end

data/test/test_messenger.rb

@@ -1,41 +0,0 @@
-require "test_helper"
-
-module Messenger
-
-  class MessengerTest < Test::Unit::TestCase
-
-    should "determine the proper protocol" do
-      assert_equal :email, Messenger.protocol("mailto:test@example.com")
-      assert_equal :email, Messenger.protocol("test@example.com")
-      assert_equal :http, Messenger.protocol("http://example.com")
-      assert_equal :http, Messenger.protocol("https://example.com")
-      assert_equal :jabber, Messenger.protocol("jabber://test@example.com")
-      assert_equal :campfire, Messenger.protocol("campfire://api_key:room_id@subdomain.campfirenow.com")
-      assert_nil Messenger.protocol("bogus")
-    end
-
-    should "determine the proper notification handler given a protocol" do
-      assert_equal Email, Messenger.handler("mailto:test@example.com")
-      assert_equal Email, Messenger.handler("test@example.com")
-      assert_equal Web, Messenger.handler("http://example.com")
-      assert_equal Web, Messenger.handler("https://example.com")
-      assert_equal Jabber, Messenger.handler("jabber://test@example.com")
-      assert_equal Campfire, Messenger.handler("campfire://api_key:room_id@subdomain.campfirenow.com")
-      assert_raises Messenger::ProtocolError do
-        Messenger.handler("example.com")
-      end
-    end
-
-    should "determine valid URLs" do
-      assert Messenger.valid_url?("mailto:test@example.com")
-      assert Messenger.valid_url?("test@example.com")
-      assert Messenger.valid_url?("http://example.com")
-      assert Messenger.valid_url?("https://example.com")
-      assert Messenger.valid_url?("jabber://test@example.com")
-      assert Messenger.valid_url?("campfire://api_key:room_id@subdomain.campfirenow.com")
-      assert !Messenger.valid_url?("bogus")
-    end
-
-  end
-
-end

data/test/test_notifo.rb

@@ -1,40 +0,0 @@
-require "test_helper"
-require 'httparty'
-
-module Messenger
-
-  class NotifoTest < Test::Unit::TestCase
-
-    context "Notifo notification" do
-      should "post a successful message" do
-        stub_request(:post, "https://api.notifo.com/v1/send_notification").to_return(:status => 200)
-        result = Notifo.send("notifo://testuser", 'message')
-        assert result.success?
-      end
-
-      should "post a failed message" do
-        stub_request(:post, "https://api.notifo.com/v1/send_notification").to_return(:status => 400)
-        result = Notifo.send("notifo://testuser", 'message')
-        assert !result.success?
-      end
-
-      should "raise when sending to an invalid URL" do
-        assert_raises URLError do
-          Notifo.send("notifo://", 'message')
-        end
-      end
-    end
-
-    context "Notifo URL validation" do
-      should "return true for good URLs" do
-        assert true, Notifo.valid_url?("notifo://testuser")
-      end
-
-      should "return false for bad URLs" do
-        assert_equal false, Notifo.valid_url?("notifo://")
-      end
-    end
-
-  end
-
-end

data/test/test_result.rb

@@ -1,25 +0,0 @@
-require "test_helper"
-
-module Messenger
-
-  class ResultTest < Test::Unit::TestCase
-
-    context "A result" do
-
-      should "return success as a boolean" do
-        result = Result.new(true, "Response")
-        assert result.success?
-        result = Result.new(false, "Response")
-        assert_equal false, result.success?
-      end
-
-      should "give access to the raw response" do
-        result = Result.new(true, "Response")
-        assert_equal "Response", result.response
-      end
-
-    end
-
-  end
-
-end

data/test/test_web.rb

@@ -1,65 +0,0 @@
-require "test_helper"
-require 'httparty'
-
-module Messenger
-
-  class WebTest < Test::Unit::TestCase
-
-    context "Web notification" do
-      setup do
-        @success_response = stub("response", :code => 200)
-        @failure_response = stub("response", :code => 500)
-      end
-
-      should "post a successful message" do
-        HTTParty.expects(:post).with("http://example.com", :body => '{ "key": "value" }', :headers => { "Content-Type" => "application/json" }).returns(@success_response)
-        result = Web.send("http://example.com", '{ "key": "value" }', :headers => { "Content-Type" => "application/json" })
-        assert result.success?
-        assert_equal @success_response, result.response
-      end
-
-      should "post a failed message" do
-        HTTParty.expects(:post).with("http://example.com", :body => '{ "key": "value" }', :headers => { "Content-Type" => "application/json" }).returns(@failure_response)
-        result = Web.send("http://example.com", '{ "key": "value" }', :headers => { "Content-Type" => "application/json" })
-        assert_equal false, result.success?
-        assert_equal @failure_response, result.response
-      end
-
-      should "raise if trying to send to an invalid URL" do
-        assert_raises URLError do
-          Web.send("http://!", :body => "whatever")
-        end
-      end
-
-      should "obfuscate the URL" do
-        assert_equal "http://example.com", Web.obfuscate("http://example.com")
-        assert_equal "http://user:xxxx@example.com", Web.obfuscate("http://user:secure_pass@example.com")
-        assert_equal "https://user:xxxx@example.com", Web.obfuscate("https://user:secure_pass@example.com")
-      end
-
-      should "raise if trying to obfuscate an invalid URL" do
-        assert_raises URLError do
-          Web.obfuscate("http://!")
-        end
-      end
-    end
-
-    context "Web notificaiton URL validation" do
-      should "return true for good URLs" do
-        assert true, Web.valid_url?("http://example.com")
-        assert true, Web.valid_url?("https://example.com")
-        assert true, Web.valid_url?("https://user@example.com")
-        assert true, Web.valid_url?("http://user:pass@example.com")
-        assert true, Web.valid_url?("https://user:#{URI.escape('!#$%^&*¢ç⎋')}@example.com")
-      end
-
-      should "return false for bad URLs" do
-        assert_equal false, Web.valid_url?("http://!")
-        assert_equal false, Web.valid_url?("http://")
-        assert_equal false, Web.valid_url?("https://")
-      end
-    end
-
-  end
-
-end