pingfm 1.0.0

data/lib/pingfm/keyloader.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+
+module Pingfm
+
+  class KeyloadingError < Exception; end
+
+  # manages the YAML file containing the keys - encryption might be nice, might be overkill
+  class Keyloader
+
+    # Path to YAML file containing keys
+    attr_accessor :keyfile
+
+    # ping.fm uses this as the key for the registered application
+    attr_accessor :api_key
+
+    # ping.fm uses this as the key for the user
+    attr_accessor :app_key
+
+    def initialize(keyfile = File.expand_path('~/.pingfm_keys.yml'))
+      @api_key = nil
+      @keyfile = keyfile
+
+      # load keys on init
+      load_keys!
+    end
+
+    # load a new set of keys
+    def load_keys(keyfile)
+      if File.exist?(keyfile) and File.readable?(keyfile)
+        data = YAML::load_file(keyfile)
+        @keyfile = keyfile if @keyfile.nil?
+        @api_key = data['api_key']
+        @app_key = data['app_key']
+      end
+    end
+
+    # load keys using the known keyfile
+    def load_keys!
+      load_keys(@keyfile)
+    end
+
+    # if keys have been loaded successfully
+    def has_keys?
+      return true unless @api_key.nil? or @app_key.nil?
+      return false
+    end
+
+    # save key data to keyfile
+    def save
+      File.open( @keyfile, 'w+' ) do |out|
+        YAML::dump( {'api_key' => @api_key, 'app_key' => @app_key}, out )
+      end
+    end
+  end
+end

data/spec/keyloader_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+require 'tempfile'
+
+describe Pingfm::Keyloader do
+
+  before(:each) do
+    @keydata = {'api_key' => 'foo', 'app_key' => 'bar'}
+    @tf = Tempfile.new('keys.yml')
+    YAML::dump(@keydata, @tf)
+    @tmp_path = @tf.path
+    @tf.close
+  end
+
+  after(:each) do
+    @tf.unlink
+  end
+
+  it "should use keys from yaml file if found" do
+    loader = Pingfm::Keyloader.new(@tmp_path)
+    loader.has_keys?.should be_true
+    loader.keyfile.should eql(@tmp_path)
+    loader.api_key.should eql(@keydata['api_key'])
+    loader.app_key.should eql(@keydata['app_key'])
+  end
+
+  it "should save keys to keyfile" do
+    loader = Pingfm::Keyloader.new(@tmp_path)
+    loader.app_key = 'baz'
+    loader.save
+
+    loader.has_keys?.should be_true
+    File.exist?(loader.keyfile).should be_true
+    File.readable?(loader.keyfile).should be_true
+    YAML::load_file(loader.keyfile)['app_key'].should eql('baz')
+  end
+
+  it "should behave if keys cannot be loaded" do
+    loader = Pingfm::Keyloader.new('/tmp/nofile')
+    loader.has_keys?.should be_false
+    loader.api_key.should be_nil
+    loader.app_key.should be_nil
+  end
+end

data/spec/pingfm_spec.rb

@@ -0,0 +1,159 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+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 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')
+  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
+end
+
+# EOF

data/spec/spec_helper.rb

@@ -0,0 +1,130 @@
+# $Id$
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib pingfm]))
+
+# Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+# end
+
+def init_ok_response(service_type)
+  @service_type = service_type
+  @response = <<EOXML
+<?xml version="1.0"?>
+<rsp status="OK">
+<transaction>12345</transaction>
+<method>#{@service_type}</method>
+</rsp>
+EOXML
+end
+
+def init_fail_response(service_type)
+  @service_type = service_type
+  @response = <<EOXML
+<?xml version="1.0"?>
+<rsp status="FAIL">
+  <transaction>12345</transaction>
+  <method>#{@service_type}</method>
+  <message>You suck</message>
+</rsp>
+EOXML
+end
+
+def init_service_response
+  @service_type = 'user.services'
+  @response = <<EOXML
+<?xml version="1.0"?>
+<rsp status="OK">
+  <transaction>12345</transaction>
+  <method>user.services</method>
+  <services>
+    <service id="twitter" name="Twitter">
+      <trigger>@tt</trigger>
+      <url>http://twitter.com/</url>
+      <icon>http://p.ping.fm/static/icons/twitter.png</icon>
+      <methods>microblog,status</methods>
+    </service>
+    <service id="facebook" name="Facebook">
+      <trigger>@fb</trigger>
+      <url>http://www.facebook.com/</url>
+      <icon>http://p.ping.fm/static/icons/facebook.png</icon>
+      <methods>status</methods>
+    </service>
+  </services>
+</rsp>
+EOXML
+end
+
+def init_trigger_response
+  @service_type = 'user.triggers'
+  @response = <<EOXML
+<?xml version="1.0"?>
+<rsp status="OK">
+  <transaction>12345</transaction>
+  <method>user.triggers</method>
+  <triggers>
+    <trigger id="twt" method="microblog">
+      <services>
+        <service id="twitter" name="Twitter"/>
+      </services>
+    </trigger>
+    <trigger id="fb" method="status">
+      <services>
+        <service id="facebook" name="Facebook"/>
+      </services>
+    </trigger>
+  </triggers>
+</rsp>
+EOXML
+end
+
+def init_latest_response
+  @service_type = 'user.latest'
+  @response = <<EOXML
+  <?xml version="1.0"?>
+<rsp status="OK">
+  <transaction>12345</transaction>
+  <method>user.latest</method>
+  <messages>
+    <message id="12345" method="blog">
+      <date rfc="Tue, 15 Apr 2008 13:56:18 -0500" unix="1234567890" />
+      <services>
+        <service id="blogger" name="Blogger"/>
+      </services>
+      <content>
+        <title>SnVzdCBoYW5naW4nIG91dCE=</title>
+        <body>R29pbmcgdG8gdGhlIHN0b3JlLg==</body>
+      </content>
+    </message>
+    <message id="12345" method="microblog">
+      <date rfc="Tue, 15 Apr 2008 13:56:18 -0500" unix="1234567890" />
+      <services>
+        <service id="twitter" name="Twitter"/>
+      </services>
+      <content>
+        <body>R29pbmcgdG8gdGhlIHN0b3JlLg==</body>
+      </content>
+    </message>
+    <message id="12345" method="status">
+      <date rfc="Tue, 15 Apr 2008 13:56:18 -0500" unix="1234567890" />
+      <services>
+        <service id="twitter" name="Twitter"/>
+        <service id="facebook" name="Facebook"/>
+      </services>
+      <content>
+        <body>aXMgdGVzdGluZyBQaW5nLmZtIQ==</body>
+      </content>
+    </message>
+  </messages>
+</rsp>
+EOXML
+end
+
+# EOF

data/tasks/ann.rake

@@ -0,0 +1,81 @@
+# $Id$
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF