pusher 0.3.5 → 0.4.0.beta

data/README.md

@@ -6,13 +6,18 @@ Getting started
 
 After registering at <http://pusherapp.com> configure your app with the security credentials
 
+    Pusher.app_id = 'your-pusher-app-id'
     Pusher.key = 'your-pusher-key'
     Pusher.secret = 'your-pusher-secret'
 
-Trigger an event
+Trigger an event. Channel and event names may only contain alphanumeric characters, '-' and '_'.
+
+    Pusher['a_channel'].trigger('an_event', {:some => 'data'})
+
+Optionally a socket id may be provided. This will prevent the event from being triggered on this specific socket id (see <http://pusherapp.com/docs/duplicates> for more info).
+
+    Pusher['a_channel'].trigger('an_event', {:some => 'data'}, socket_id)
 
-    Pusher['arbitrary-channel-name'].trigger({:some => 'data'})
-    
 Logging
 -------
 

data/Rakefile

@@ -12,7 +12,9 @@ begin
     gem.authors = ["New Bamboo"]
     # gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
     gem.add_dependency "json"
+    gem.add_dependency "crack"
     gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "webmock"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.4.0.beta

data/lib/pusher.rb

@@ -5,16 +5,13 @@ require 'net/http'
 autoload 'Logger', 'logger'
 
 module Pusher
-  class ArgumentError < ::ArgumentError
-    def message
-      'You must configure both Pusher.key in order to authenticate your Pusher app'
-    end
-  end
+  class Error < RuntimeError; end
+  class AuthenticationError < Error; end
 
   class << self
     attr_accessor :host, :port
     attr_writer :logger
-    attr_accessor :key, :secret
+    attr_accessor :app_id, :key, :secret
 
     def logger
       @logger ||= begin
@@ -23,16 +20,21 @@ module Pusher
         log
       end
     end
+    
+    def authentication_token
+      Authentication::Token.new(@key, @secret)
+    end
   end
 
   self.host = 'api.pusherapp.com'
   self.port = 80
 
-  def self.[](channel_id)
-    raise ArgumentError unless @key
+  def self.[](channel_name)
+    raise ArgumentError, 'Missing configuration: please check that Pusher.app_id, Pusher.key, and Pusher.secret are all configured' unless @app_id && @key && @secret
     @channels ||= {}
-    @channels[channel_id.to_s] = Channel.new(@key, channel_id)
+    @channels[channel_name.to_s] = Channel.new(@app_id, channel_name)
   end
 end
 
 require 'pusher/channel'
+require 'pusher/authentication'

data/lib/pusher/authentication.rb

@@ -0,0 +1,144 @@
+require 'hmac-sha2'
+require 'base64'
+
+module Authentication
+  class AuthenticationError < RuntimeError; end
+
+  class Token
+    attr_reader :key, :secret
+
+    def initialize(key, secret)
+      @key, @secret = key, secret
+    end
+
+    def sign(request)
+      request.sign(self)
+    end
+  end
+
+  class Request
+    attr_accessor :path, :query_hash
+
+    # http://www.w3.org/TR/NOTE-datetime
+    ISO8601 = "%Y-%m-%dT%H:%M:%SZ"
+
+    def initialize(method, path, query)
+      raise ArgumentError, "Expected string" unless path.kind_of?(String)
+      raise ArgumentError, "Expected hash" unless query.kind_of?(Hash)
+
+      query_hash = {}
+      auth_hash = {}
+      query.each do |key, v|
+        k = key.to_s.downcase
+        k[0..4] == 'auth_' ? auth_hash[k] = v : query_hash[k] = v
+      end
+
+      @method = method.upcase
+      @path, @query_hash, @auth_hash = path, query_hash, auth_hash
+    end
+
+    def sign(token)
+      @auth_hash = {
+        :auth_version => "1.0",
+        :auth_key => token.key,
+        :auth_timestamp => Time.now.to_i
+      }
+
+      hmac_signature = HMAC::SHA256.digest(token.secret, string_to_sign)
+      # chomp because the Base64 output ends with \n
+      @auth_hash[:auth_signature] = Base64.encode64(hmac_signature).chomp
+
+      return @auth_hash
+    end
+
+    # Authenticates the request with a token
+    #
+    # Timestamp check: Unless timestamp_grace is set to nil (which will skip
+    # the timestamp check), an exception will be raised if timestamp is not
+    # supplied or if the timestamp provided is not within timestamp_grace of
+    # the real time (defaults to 10 minutes)
+    #
+    # Signature check: Raises an exception if the signature does not match the
+    # computed value
+    #
+    def authenticate_by_token!(token, timestamp_grace = 600)
+      validate_version!
+      validate_timestamp!(timestamp_grace)
+      validate_signature!(token)
+      true
+    end
+
+    def authenticate_by_token(token, timestamp_grace = 600)
+      authenticate_by_token!(token, timestamp_grace)
+    rescue AuthenticationError
+      false
+    end
+
+    def authenticate(timestamp_grace = 600, &block)
+      key = @auth_hash['auth_key']
+      raise AuthenticationError, "Authentication key required" unless key
+      token = yield key
+      unless token && token.secret
+        raise AuthenticationError, "Invalid authentication key"
+      end
+      authenticate_by_token!(token, timestamp_grace)
+      return token
+    end
+
+    def auth_hash
+      raise "Request not signed" unless @auth_hash && @auth_hash[:auth_signature]
+      @auth_hash
+    end
+
+    private
+
+      def string_to_sign
+        [@method, @path, parameter_string].join("\n")
+      end
+
+      def parameter_string
+        param_hash = @query_hash.merge(@auth_hash || {})
+
+        # Convert keys to lowercase strings
+        hash = {}; param_hash.each { |k,v| hash[k.to_s.downcase] = v }
+
+        # Exclude signature from signature generation!
+        hash.delete("auth_signature")
+
+        hash.keys.sort.map { |k| "#{k}=#{hash[k]}" }.join("&")
+      end
+
+      def validate_version!
+        version = @auth_hash["auth_version"]
+        raise AuthenticationError, "Version required" unless version
+        raise AuthenticationError, "Version not supported" unless version == '1.0'
+      end
+
+      def validate_timestamp!(grace)
+        return true if grace.nil?
+
+        timestamp = @auth_hash["auth_timestamp"]
+        error = (timestamp.to_i - Time.now.to_i).abs
+        raise AuthenticationError, "Timestamp required" unless timestamp
+        if error >= grace
+          raise AuthenticationError, "Timestamp expired: Given timestamp "\
+            "(#{Time.at(timestamp.to_i).utc.strftime(ISO8601)}) "\
+            "not within #{grace}s of server time "\
+            "(#{Time.now.utc.strftime(ISO8601)})"
+        end
+        return true
+      end
+
+      def validate_signature!(token)
+        string = string_to_sign
+        hmac_signature = HMAC::SHA256.digest(token.secret, string)
+        # chomp because the Base64 output ends with \n
+        base64_signature = Base64.encode64(hmac_signature).chomp
+        unless @auth_hash["auth_signature"] == base64_signature
+          raise AuthenticationError, "Invalid signature: you should have "\
+            "sent Base64Encode(HmacSHA256(#{string.inspect}, your_secret_key))"
+        end
+        return true
+      end
+  end
+end

data/lib/pusher/channel.rb

@@ -1,24 +1,62 @@
+require 'crack/core_extensions' # Used for Hash#to_params
+require 'digest/md5'
+
 module Pusher
   class Channel
-    def initialize(key, id)
-      @uri = URI.parse("http://#{Pusher.host}:#{Pusher.port}/app/#{key}/channel/#{id}")
+    def initialize(app_id, name)
+      @uri = URI::HTTP.build({
+        :host => Pusher.host,
+        :port => Pusher.port,
+        :path => "/apps/#{app_id}/channels/#{name}/events"
+      })
       @http = Net::HTTP.new(@uri.host, @uri.port)
     end
 
-    def trigger(event_name, data, socket_id = nil)
-      begin
-        @http.post(
-          @uri.path,
-          self.class.turn_into_json({
-            :event => event_name,
-            :data => data,
-            :socket_id => socket_id
-          }),
-          {'Content-Type'=> 'application/json'}
-        )
-      rescue StandardError => e
-        handle_error e
+    def trigger!(event_name, data, socket_id = nil)
+      params = {
+        :name => event_name,
+      }
+      params[:socket_id] = socket_id if socket_id
+
+      body = case data
+      when String
+        data
+      else
+        begin
+          self.class.turn_into_json(data)
+        rescue => e
+          Pusher.logger.error("Could not convert #{data.inspect} into JSON")
+          raise e
+        end
       end
+      params[:body_md5] = Digest::MD5.hexdigest(body)
+
+      request = Authentication::Request.new('POST', @uri.path, params)
+      auth_hash = request.sign(Pusher.authentication_token)
+
+      query_params = params.merge(auth_hash)
+      @uri.query = query_params.to_params
+
+      response = @http.post("#{@uri.path}?#{@uri.query}", body, {
+        'Content-Type'=> 'application/json'
+      })
+
+      case response.code
+      when "202"
+        return true
+      when "401"
+        raise AuthenticationError, response.body.chomp
+      when "404"
+        raise Error, "Resource not found: app_id is probably invalid"
+      else
+        raise Error, "Unknown error in Pusher: #{response.body.chomp}"
+      end
+    end
+
+    def trigger(event_name, data, socket_id = nil)
+      trigger!(event_name, data, socket_id)
+    rescue StandardError => e
+      handle_error e
     end
 
     def self.turn_into_json(data)

data/pusher.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pusher}
-  s.version = "0.3.5"
+  s.version = "0.4.0.beta"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["New Bamboo"]
-  s.date = %q{2010-04-15}
+  s.date = %q{2010-04-22}
   s.description = %q{Wrapper for pusherapp.com REST api}
   s.email = %q{support@pusherapp.com}
   s.extra_rdoc_files = [
@@ -24,8 +24,10 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/pusher.rb",
+     "lib/pusher/authentication.rb",
      "lib/pusher/channel.rb",
      "pusher.gemspec",
+     "spec/authentication_spec.rb",
      "spec/pusher_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
@@ -36,7 +38,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{Pusher App client}
   s.test_files = [
-    "spec/pusher_spec.rb",
+    "spec/authentication_spec.rb",
+     "spec/pusher_spec.rb",
      "spec/spec_helper.rb"
   ]
 
@@ -46,14 +49,20 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<crack>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
     else
       s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<crack>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<webmock>, [">= 0"])
     end
   else
     s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<crack>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<webmock>, [">= 0"])
   end
 end
 

data/spec/authentication_spec.rb

@@ -0,0 +1,176 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Authentication do
+  before :each do
+    Time.stub!(:now).and_return(Time.at(1234))
+
+    @token = Authentication::Token.new('key', 'secret')
+
+    @request = Authentication::Request.new('POST', '/some/path', {
+      "query" => "params",
+      "go" => "here"
+    })
+    @signature = @request.sign(@token)[:auth_signature]
+  end
+
+  it "should generate base64 encoded signature from correct key" do
+    @request.send(:string_to_sign).should == "POST\n/some/path\nauth_key=key&auth_timestamp=1234&auth_version=1.0&go=here&query=params"
+    @signature.should == 'OyN5U6W6ZhmHXLsqLUPo2p71gk6KLGifYoSshbweoNs='
+  end
+
+  it "should make auth_hash available after request is signed" do
+    request = Authentication::Request.new('POST', '/some/path', {
+      "query" => "params"
+    })
+    lambda {
+      request.auth_hash
+    }.should raise_error('Request not signed')
+
+    request.sign(@token)
+    request.auth_hash.should == {
+      :auth_signature => "2gePzt1ylBtshzyqQNDWsgAOv8cAzugCsSjdIPcudOk=",
+      :auth_version => "1.0",
+      :auth_key => "key",
+      :auth_timestamp => 1234
+    }
+  end
+
+  it "should cope with symbol keys" do
+    @request.query_hash = {
+      :query => "params",
+      :go => "here"
+    }
+    @request.sign(@token)[:auth_signature].should == @signature
+  end
+
+  it "should cope with upcase keys (keys are lowercased before signing)" do
+    @request.query_hash = {
+      "Query" => "params",
+      "GO" => "here"
+    }
+    @request.sign(@token)[:auth_signature].should == @signature
+  end
+
+  it "should use the path to generate signature" do
+    @request.path = '/some/other/path'
+    @request.sign(@token)[:auth_signature].should_not == @signature
+  end
+
+  it "should use the query string keys to generate signature" do
+    @request.query_hash = {
+      "other" => "query"
+    }
+    @request.sign(@token)[:auth_signature].should_not == @signature
+  end
+
+  it "should use the query string values to generate signature" do
+    @request.query_hash = {
+      "key" => "notfoo",
+      "other" => 'bar'
+    }
+    @request.sign(@token)[:signature].should_not == @signature
+  end
+
+  describe "verification" do
+    before :each do
+      Time.stub!(:now).and_return(Time.at(1234))
+      @request.sign(@token)
+      @params = @request.query_hash.merge(@request.auth_hash)
+    end
+
+    it "should verify requests" do
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      request.authenticate_by_token(@token).should == true
+    end
+
+    it "should raise error if signature is not correct" do
+      @params[:auth_signature] =  'asdf'
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      lambda {
+        request.authenticate_by_token!(@token)
+      }.should raise_error('Invalid signature: you should have sent Base64Encode(HmacSHA256("POST\n/some/path\nauth_key=key&auth_timestamp=1234&auth_version=1.0&go=here&query=params", your_secret_key))')
+    end
+
+    it "should raise error if timestamp not available" do
+      @params.delete(:auth_timestamp)
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      lambda {
+        request.authenticate_by_token!(@token)
+      }.should raise_error('Timestamp required')
+    end
+
+    it "should raise error if timestamp has expired (default of 600s)" do
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      Time.stub!(:now).and_return(Time.at(1234 + 599))
+      request.authenticate_by_token!(@token).should == true
+      Time.stub!(:now).and_return(Time.at(1234 - 599))
+      request.authenticate_by_token!(@token).should == true
+      Time.stub!(:now).and_return(Time.at(1234 + 600))
+      lambda {
+        request.authenticate_by_token!(@token)
+      }.should raise_error("Timestamp expired: Given timestamp (1970-01-01T00:20:34Z) not within 600s of server time (1970-01-01T00:30:34Z)")
+      Time.stub!(:now).and_return(Time.at(1234 - 600))
+      lambda {
+        request.authenticate_by_token!(@token)
+      }.should raise_error("Timestamp expired: Given timestamp (1970-01-01T00:20:34Z) not within 600s of server time (1970-01-01T00:10:34Z)")
+    end
+
+    it "should be possible to customize the timeout grace period" do
+      grace = 10
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      Time.stub!(:now).and_return(Time.at(1234 + grace - 1))
+      request.authenticate_by_token!(@token, grace).should == true
+      Time.stub!(:now).and_return(Time.at(1234 + grace))
+      lambda {
+        request.authenticate_by_token!(@token, grace)
+      }.should raise_error("Timestamp expired: Given timestamp (1970-01-01T00:20:34Z) not within 10s of server time (1970-01-01T00:20:44Z)")
+    end
+
+    it "should be possible to skip timestamp check by passing nil" do
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      Time.stub!(:now).and_return(Time.at(1234 + 1000))
+      request.authenticate_by_token!(@token, nil).should == true
+    end
+    
+    it "should check that auth_version is supplied" do
+      @params.delete(:auth_version)
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      lambda {
+        request.authenticate_by_token!(@token)
+      }.should raise_error('Version required')
+    end
+
+    it "should check that auth_version equals 1.0" do
+      @params[:auth_version] = '1.1'
+      request = Authentication::Request.new('POST', '/some/path', @params)
+      lambda {
+        request.authenticate_by_token!(@token)
+      }.should raise_error('Version not supported')
+    end
+
+    describe "when used with optional block" do
+      it "should optionally take a block which yields the signature" do
+        request = Authentication::Request.new('POST', '/some/path', @params)
+        request.authenticate do |key|
+          key.should == @token.key
+          @token
+        end.should == @token
+      end
+
+      it "should raise error if no auth_key supplied to request" do
+        @params.delete(:auth_key)
+        request = Authentication::Request.new('POST', '/some/path', @params)
+        lambda {
+          request.authenticate { |key| nil }
+        }.should raise_error('Authentication key required')
+      end
+
+      it "should raise error if block returns nil (i.e. key doesn't exist)" do
+        request = Authentication::Request.new('POST', '/some/path', @params)
+        lambda {
+          request.authenticate { |key| nil }
+        }.should raise_error('Invalid authentication key')
+      end
+    end
+  end
+end

data/spec/pusher_spec.rb

@@ -1,5 +1,7 @@
 require File.expand_path('../spec_helper', __FILE__)
 
+require 'webmock/rspec'
+
 describe Pusher do
   describe 'configuration' do
     it 'should be preconfigured for api host' do
@@ -22,27 +24,17 @@ describe Pusher do
       Pusher.logger.debug('foo')
       Pusher.logger = nil
     end
-
-    it 'should raise exception if key and secret are missing' do
-      lambda {
-        Pusher['test-channel']
-      }.should raise_error(Pusher::ArgumentError)
-    end
-
-    it 'should raise exception if key is missing' do
-      lambda {
-        Pusher['test-channel']
-      }.should raise_error(Pusher::ArgumentError)
-    end
   end
 
   describe 'configured' do
     before do
+      Pusher.app_id = '20'
       Pusher.key    = '12345678900000001'
       Pusher.secret = '12345678900000001'
     end
 
     after do
+      Pusher.app_id = nil
       Pusher.key = nil
       Pusher.secret = nil
     end
@@ -55,34 +47,102 @@ describe Pusher do
       it 'should return a new channel' do
         @channel.should be_kind_of(Pusher::Channel)
       end
+
+      %w{app_id key secret}.each do |config|
+        it "should raise exception if #{config} not configured" do
+          Pusher.send("#{config}=", nil)
+          lambda {
+            Pusher['test_channel']
+          }.should raise_error(ArgumentError)
+        end
+      end
     end
 
-    describe 'Channel#trigger' do
-      before do
-        @http = mock('HTTP', :post => 'posting')
-        Net::HTTP.stub!(:new).and_return @http
+    describe 'Channel#trigger!' do
+      before :each do
+        WebMock.stub_request(:post, %r{/app/20/channel/test_channel/event})
+        @channel = Pusher['test_channel']
       end
 
       it 'should configure HTTP library to talk to pusher API' do
-        Net::HTTP.should_receive(:new).
-          with('api.pusherapp.com', 80).and_return @http
-        Pusher['test_channel'].trigger('new_event', 'Some data')
+        @channel.trigger!('new_event', 'Some data')
+        WebMock.request(:post, %r{api.pusherapp.com}).should have_been_made
       end
 
-      it 'should POST JSON to pusher API' do
-        @http.should_receive(:post) do |path, data, headers|
-          path.should == '/app/12345678900000001/channel/test_channel'
-          parsed = JSON.parse(data)
-          parsed['event'].should == 'new_event'
-          parsed['data']['name'].should == 'Pusher'
-          parsed['data']['last_name'].should == 'App'
-          parsed['socket_id'].should == nil
-          headers.should == {'Content-Type'=> 'application/json'}
-        end
-        Pusher['test_channel'].trigger('new_event', {
+      it 'should POST with the correct parameters and convert data to JSON' do
+        @channel.trigger!('new_event', {
           :name => 'Pusher',
           :last_name => 'App'
         })
+        WebMock.request(:post, %r{/app/20/channel/test_channel/event}).
+        with do |req|
+
+          query_hash = req.uri.query_values
+          query_hash["name"].should == 'new_event'
+          query_hash["auth_key"].should == Pusher.key
+          query_hash["auth_timestamp"].should_not be_nil
+
+          parsed = JSON.parse(req.body)
+          parsed.should == {
+            "name" => 'Pusher',
+            "last_name" => 'App'
+          }
+
+          req.headers['Content-Type'].should == 'application/json'
+        end.should have_been_made
+      end
+
+      it "should handle string data by sending unmodified in body" do
+        string = "foo\nbar\""
+        @channel.trigger!('new_event', string)
+        WebMock.request(:post, %r{/app/20/channel/test_channel/event}).with do |req|
+          req.body.should == "foo\nbar\""
+        end.should have_been_made
+      end
+
+      it "should raise error if an object sent which canot be JSONified" do
+        lambda {
+          @channel.trigger!('new_event', Object.new)
+        }.should raise_error(JSON::GeneratorError)
+      end
+
+      it "should propagate exception if exception raised" do
+        WebMock.stub_request(:post, %r{/app/20/channel/test_channel/event}).
+          to_raise(RuntimeError)
+        lambda {
+          Pusher['test_channel'].trigger!('new_event', 'Some data')
+        }.should raise_error(RuntimeError)
+      end
+
+      it "should raise AuthenticationError if pusher returns 401" do
+        WebMock.stub_request(:post, %r{/app/20/channel/test_channel/event}).
+          to_return(:status => 401)
+        lambda {
+          Pusher['test_channel'].trigger!('new_event', 'Some data')
+        }.should raise_error(Pusher::AuthenticationError)
+      end
+
+      it "should raise Pusher::Error if pusher returns 404" do
+        WebMock.stub_request(:post, %r{/app/20/channel/test_channel/event}).
+          to_return(:status => 404)
+        lambda {
+          Pusher['test_channel'].trigger!('new_event', 'Some data')
+        }.should raise_error(Pusher::Error, 'Resource not found: app_id is probably invalid')
+      end
+
+      it "should raise Pusher::Error if pusher returns 500" do
+        WebMock.stub_request(:post, %r{/app/20/channel/test_channel/event}).
+          to_return(:status => 500, :body => "some error")
+        lambda {
+          Pusher['test_channel'].trigger!('new_event', 'Some data')
+        }.should raise_error(Pusher::Error, 'Unknown error in Pusher: some error')
+      end
+    end
+
+    describe 'Channel#trigger' do
+      before :each do
+        @http = mock('HTTP', :post => 'posting')
+        Net::HTTP.stub!(:new).and_return @http
       end
 
       it "should log failure if exception raised" do

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: pusher
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 0
-  - 3
-  - 5
-  version: 0.3.5
+  - 4
+  - 0
+  - beta
+  version: 0.4.0.beta
 platform: ruby
 authors: 
 - New Bamboo
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-15 00:00:00 +01:00
+date: 2010-04-22 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,9 +31,21 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: crack
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -42,7 +55,19 @@ dependencies:
         - 9
         version: 1.2.9
   type: :development
-  version_requirements: *id002
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Wrapper for pusherapp.com REST api
 email: support@pusherapp.com
 executables: []
@@ -60,8 +85,10 @@ files:
 - Rakefile
 - VERSION
 - lib/pusher.rb
+- lib/pusher/authentication.rb
 - lib/pusher/channel.rb
 - pusher.gemspec
+- spec/authentication_spec.rb
 - spec/pusher_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -83,11 +110,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
@@ -96,5 +125,6 @@ signing_key:
 specification_version: 3
 summary: Pusher App client
 test_files: 
+- spec/authentication_spec.rb
 - spec/pusher_spec.rb
 - spec/spec_helper.rb