pingfm 1.0.2 → 2.0.0

data/lib/pingfm/config.rb

@@ -0,0 +1,36 @@
+module Pingfm
+  class ConfigNotFound < Exception; end
+
+  class Config
+    CONFIG_PATH = (RUBY_PLATFORM =~ /mswin32/ ? ENV['HOMEPATH'] : ENV['HOME'])
+    CONFIG_FILE = File.expand_path(File.join(CONFIG_PATH, '.pingfm.yml'))
+
+    class << self
+
+      # Prompts the user for their API key and saves it.
+      def ask_for_app_key!
+        STDOUT.print 'Enter your Ping.fm User API key (http://ping.fm/key/): '
+        @@config ||= {}
+        @@config['app_key'] = STDIN.gets.chomp
+        save!
+      end
+
+      def [](key)
+        setup! unless defined?(@@config)
+        @@config[key]
+      end
+
+      def save!
+        ::File.open(CONFIG_FILE, 'w') do |config_file|
+          ::YAML.dump(@@config, config_file)
+        end
+      end
+
+      def setup!(config_file = CONFIG_FILE)
+        raise Pingfm::ConfigNotFound unless File.exists?(config_file)
+        @@config = ::YAML.load_file(config_file)
+      end
+
+    end
+  end
+end

data/pingfm.gemspec

@@ -0,0 +1,27 @@
+$LOAD_PATH.push(File.expand_path("../lib", __FILE__))
+require 'pingfm'
+
+Gem::Specification.new do |s|
+  s.name = "pingfm"
+  s.version = Pingfm::VERSION
+
+  s.authors = ["Dale Campbell", "Kevin Williams", "Krunoslav Husak"]
+  s.email = ["oshuma@gmail.com", "kevwil@gmail.com"]
+  s.homepage = "http://github.com/Oshuma/pingfm"
+
+  s.rubyforge_project = 'pingfm'
+
+  s.summary = %q{A Ping.fm Ruby library.}
+  s.description = %q{Ping.fm (http://ping.fm) is a simple service that makes updating your social networks a snap, and this it's Ruby library.}
+
+  s.add_dependency('slop')
+  s.add_development_dependency('rspec', '>= 2.6.0')
+
+  s.has_rdoc = true
+  s.rdoc_options = ['--inline-source']
+
+  s.require_paths = ["lib"]
+  s.files       = `git ls-files`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+end

data/spec/pingfm/client_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe Pingfm::Client do
+  it 'should have an API_URL' do
+    Pingfm::Client::API_URL.should_not be_nil
+  end
+
+  it 'should have an API_KEY' do
+    Pingfm::Client::API_KEY.should_not be_nil
+  end
+end
+
+describe Pingfm::Client, "with expected results" do
+
+  before(:each) do
+    @client = Pingfm::Client.new('b')
+    @params = {'api_key' => Pingfm::Client::API_KEY, 'user_app_key' => 'b'}
+  end
+
+  it "should validate keys successfully" do
+    init_ok_response 'user.validate'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.validate
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+  end
+
+  it "should list the user's services properly" do
+    init_service_response
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.services
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+    result['services'].should_not be_nil
+    result['services'].should_not be_empty
+    result['services'].length.should eql(2)
+    result['services'].first['id'].should eql('twitter')
+  end
+
+  it "should list the system services" do
+    init_system_services_response
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.system_services
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+    result['services'].should_not be_nil
+    result['services'].should_not be_empty
+    result['services'].length.should eql(2)
+    result['services'].first['id'].should eql('bebo')
+  end
+
+  it "should list the user's custom triggers" do
+    init_trigger_response
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.triggers
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+    result['triggers'].should_not be_nil
+    result['triggers'].should_not be_empty
+    result['triggers'].length.should eql(2)
+    result['triggers'].first['id'].should eql('twt')
+  end
+
+  it "should list the user's recent posts" do
+    init_latest_response
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+    @params.merge!('limit'=>5,'order'=>'DESC')
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.latest(5)
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+    result['messages'].should_not be_nil
+    result['messages'].should_not be_empty
+    result['messages'].length.should eql(3)
+    result['messages'].first['id'].should eql('12345')
+    result['messages'].last['location'].should_not be_empty
+  end
+
+  it "should post a message to the service" do
+    init_ok_response 'user.post'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+    @params.merge!('body' => 'foo', 'title' => '',
+    'post_method' => 'default', 'service' => '',
+    'debug' => 0)
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.post('foo')
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+  end
+
+  it "should post a message to the service using a trigger" do
+    init_ok_response 'user.tpost'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+    @params.merge!('body' => 'foo', 'title' => '',
+    'trigger' => 'twt', 'debug' => 0)
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.tpost('foo','twt')
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('OK')
+  end
+
+end
+
+describe Pingfm::Client, "with error messages" do
+
+  before(:each) do
+    @client = Pingfm::Client.new('b')
+    @params = {'api_key' => Pingfm::Client::API_KEY, 'user_app_key' => 'b'}
+  end
+
+  it "should handle a failed validate cleanly" do
+    init_fail_response 'user.validate'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.validate
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+
+  it "should handle a failed system services cleanly" do
+    init_fail_response 'system.services'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.system_services
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+
+  it "should handle a failed user's services cleanly" do
+    init_fail_response 'user.services'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.services
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+
+  it "should handle a failed user's triggers cleanly" do
+    init_fail_response 'user.triggers'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.triggers
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+
+  it "should handle a failed user's latest messages cleanly" do
+    init_fail_response 'user.latest'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    @params.merge!('order' => 'DESC', 'limit' => 25)
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.latest
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+
+  it "should handle a failed user post cleanly" do
+    init_fail_response 'user.post'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    @params.merge!({'post_method' => 'default', 'title' => '',
+                    'service' => '', 'body' => 'test message', 'debug' => 0})
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.post('test message')
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+
+  it "should handle a failed user trigger post cleanly" do
+    init_fail_response 'user.tpost'
+
+    uri = URI.parse "#{Pingfm::Client::API_URL}/#{@service_type}"
+
+    # mock the http call
+    http_resp = mock('response')
+    http_resp.should_receive(:body).and_return(@response)
+    @params.merge!({'title' => '', 'body' => 'test message',
+                    'trigger' => '@trigger', 'debug' => 0})
+    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
+
+    # call and verify
+    result = @client.tpost('test message', '@trigger')
+    result.should_not be_empty
+    result['status'].should_not be_nil
+    result['status'].should eql('FAIL')
+    result['message'].should_not be_nil
+  end
+end

data/spec/pingfm/config_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Pingfm::Config do
+
+  SPEC_CONFIG_FILE = "#{File.dirname(__FILE__)}/../pingfm_spec.yml"
+
+  it 'has a CONFIG_PATH' do
+    Pingfm::Config::CONFIG_PATH.should_not be_nil
+  end
+
+  it 'has a CONFIG_FILE' do
+    Pingfm::Config::CONFIG_FILE.should_not be_nil
+  end
+
+  it 'loads the given config file' do
+    Pingfm::Config.setup!(SPEC_CONFIG_FILE)
+    @config = ::YAML.load_file(SPEC_CONFIG_FILE)
+    Pingfm::Config['app_key'].should == @config['app_key']
+  end
+
+end

data/spec/pingfm_spec.rb

@@ -1,309 +1,7 @@
-# $Id$
-# TODO: LOTS of repetition here that can probably be refactored a bit.
-# TODO: Split these specs into a pingfm/ subdirectory, moving the client specs into their own file.
+require 'spec_helper'
 
-require File.join(File.dirname(__FILE__), %w[spec_helper])
-
-describe Pingfm, 'main module' do
+describe Pingfm do
   it 'should return the version string' do
-    Pingfm.version.should be_a_kind_of(String)
-  end
-
-  it 'should return the library path' do
-    Pingfm.libpath.should eql(Pingfm::LIBPATH)
-  end
-
-  it 'should return the path to the library' do
-    Pingfm.path.should eql(Pingfm::PATH)
+    Pingfm::VERSION.should be_a_kind_of(String)
   end
 end
-
-describe Pingfm::Client, "with expected results" do
-
-  before(:each) do
-    @client = Pingfm::Client.new('a','b')
-    @params = {'api_key' => 'a', 'user_app_key' => 'b'}
-  end
-
-  it "should validate keys successfully" do
-    init_ok_response 'user.validate'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.validate
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-  end
-
-  it "should list the user's services properly" do
-    init_service_response
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.services
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-    result['services'].should_not be_nil
-    result['services'].should_not be_empty
-    result['services'].length.should eql(2)
-    result['services'].first['id'].should eql('twitter')
-  end
-
-  it "should list the system services" do
-    init_system_services_response
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.system_services
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-    result['services'].should_not be_nil
-    result['services'].should_not be_empty
-    result['services'].length.should eql(2)
-    result['services'].first['id'].should eql('bebo')
-  end
-
-  it "should list the user's custom triggers" do
-    init_trigger_response
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.triggers
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-    result['triggers'].should_not be_nil
-    result['triggers'].should_not be_empty
-    result['triggers'].length.should eql(2)
-    result['triggers'].first['id'].should eql('twt')
-  end
-
-  it "should list the user's recent posts" do
-    init_latest_response
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-    @params.merge!('limit'=>5,'order'=>'DESC')
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.latest(5)
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-    result['messages'].should_not be_nil
-    result['messages'].should_not be_empty
-    result['messages'].length.should eql(3)
-    result['messages'].first['id'].should eql('12345')
-    result['messages'].last['location'].should_not be_empty
-  end
-
-  it "should post a message to the service" do
-    init_ok_response 'user.post'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-    @params.merge!('body' => 'foo', 'title' => '',
-    'post_method' => 'default', 'service' => '',
-    'debug' => 0)
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.post('foo')
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-  end
-
-  it "should post a message to the service using a trigger" do
-    init_ok_response 'user.tpost'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-    @params.merge!('body' => 'foo', 'title' => '',
-    'trigger' => 'twt', 'debug' => 0)
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.tpost('foo','twt')
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('OK')
-  end
-
-end
-
-describe Pingfm::Client, "with error messages" do
-  before(:each) do
-    @client = Pingfm::Client.new('a','b')
-    @params = {'api_key' => 'a', 'user_app_key' => 'b'}
-  end
-
-  it "should handle a failed validate cleanly" do
-    init_fail_response 'user.validate'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.validate
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-
-  it "should handle a failed system services cleanly" do
-    init_fail_response 'system.services'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.system_services
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-
-  it "should handle a failed user's services cleanly" do
-    init_fail_response 'user.services'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.services
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-
-  it "should handle a failed user's triggers cleanly" do
-    init_fail_response 'user.triggers'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.triggers
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-
-  it "should handle a failed user's latest messages cleanly" do
-    init_fail_response 'user.latest'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    @params.merge!('order' => 'DESC', 'limit' => 25)
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.latest
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-
-  it "should handle a failed user post cleanly" do
-    init_fail_response 'user.post'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    @params.merge!({'post_method' => 'default', 'title' => '',
-                    'service' => '', 'body' => 'test message', 'debug' => 0})
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.post('test message')
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-
-  it "should handle a failed user trigger post cleanly" do
-    init_fail_response 'user.tpost'
-
-    uri = URI.parse "#{Pingfm::API_URL}/#{@service_type}"
-
-    # mock the http call
-    http_resp = mock('response')
-    http_resp.should_receive(:body).and_return(@response)
-    @params.merge!({'title' => '', 'body' => 'test message',
-                    'trigger' => '@trigger', 'debug' => 0})
-    Net::HTTP.should_receive(:post_form).with(uri, @params).and_return(http_resp)
-
-    # call and verify
-    result = @client.tpost('test message', '@trigger')
-    result.should_not be_empty
-    result['status'].should_not be_nil
-    result['status'].should eql('FAIL')
-    result['message'].should_not be_nil
-  end
-end
-
-# EOF