slayer-rpx_now 0.6.24

data/init.rb

@@ -0,0 +1,2 @@
+#Needed to load rpx_now when used as Rails plugin
+require 'rpx_now'

data/lib/rpx_now/api.rb

@@ -0,0 +1,75 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+
+module RPXNow
+  # low-level interaction with rpxnow.com api
+  # - send requests
+  # - parse response
+  # - handle server errors
+  class Api
+    SSL_CERT = File.join(File.dirname(__FILE__), '..', '..', 'certs', 'ssl_cert.pem')
+
+    def self.call(method, data)
+      data = data.dup
+      version = RPXNow.extract_version(data)
+      data.delete(:api_version)
+
+      path = "/api/v#{version}/#{method}"
+      response = request(path, {:apiKey => RPXNow.api_key}.merge(data))
+      parse_response(response)
+    end
+
+    def self.host(subdomain=nil)
+      if subdomain
+        "https://#{subdomain}.#{RPXNow.domain}"
+      else
+        "https://#{RPXNow.domain}"
+      end
+    end
+
+    private
+
+    def self.request(path, data)
+      client.request(request_object(path, data))
+    end
+
+    def self.request_object(path, data)
+      request = Net::HTTP::Post.new(path)
+      request.form_data = stringify_keys(data)
+      request
+    end
+
+    # symbol keys -> string keys
+    # because of ruby 1.9.x bug in Net::HTTP
+    # http://redmine.ruby-lang.org/issues/show/1351
+    def self.stringify_keys(hash)
+      hash.map{|k,v| [k.to_s,v]}
+    end
+
+    def self.client
+      client = Net::HTTP.new(RPXNow.domain, 443)
+      client.use_ssl = true
+      client.ca_file = SSL_CERT
+      client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      client.verify_depth = 5
+      client
+    end
+
+    def self.parse_response(response)
+      if response.code.to_i >= 400
+        raise ServiceUnavailableError, "The RPX service is temporarily unavailable. (4XX)"
+      else
+        result = JSON.parse(response.body)
+        return result unless result['err']
+
+        code = result['err']['code']
+        if code == -1
+          raise ServiceUnavailableError, "The RPX service is temporarily unavailable."
+        else
+          raise ApiError, "Got error: #{result['err']['msg']} (code: #{code}), HTTP status: #{response.code}"
+        end
+      end
+    end
+  end
+end

data/lib/rpx_now/contacts_collection.rb

@@ -0,0 +1,20 @@
+module RPXNow
+  # Makes returned contacts feel like a array
+  class ContactsCollection < Array
+    def initialize(list)
+      @raw = list
+      @additional_info = list.reject{|k,v|k=='entry'}
+      list['entry'].each{|item| self << parse_data(item)}
+    end
+
+    def additional_info;@additional_info;end
+    def raw;@raw;end
+
+    private
+
+    def parse_data(entry)
+      entry['emails'] = (entry['emails'] ? entry['emails'].map{|email| email['value']} : [])
+      entry
+    end
+  end
+end

data/lib/rpx_now/user_integration.rb

@@ -0,0 +1,9 @@
+require 'rpx_now/user_proxy'
+
+module RPXNow
+  module UserIntegration
+    def rpx
+      RPXNow::UserProxy.new(id)
+    end
+  end
+end

data/lib/rpx_now/user_proxy.rb

@@ -0,0 +1,19 @@
+module RPXNow
+  class UserProxy
+    def initialize(id)
+      @id = id
+    end
+
+    def identifiers
+      RPXNow.mappings(@id)
+    end
+
+    def map(identifier)
+      RPXNow.map(identifier, @id)
+    end
+
+    def unmap(identifier)
+      RPXNow.unmap(identifier, @id)
+    end
+  end
+end

data/lib/rpx_now.rb

@@ -0,0 +1,201 @@
+require 'rpx_now/api'
+require 'rpx_now/contacts_collection'
+require 'cgi'
+
+module RPXNow
+  extend self
+
+  attr_accessor :api_key
+  attr_accessor :api_version
+  attr_accessor :domain
+  
+  self.api_version = 2
+  self.domain = 'rpxnow.com'
+  
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+
+  # retrieve the users data
+  # - cleaned Hash
+  # - complete/unclean response when block was given user_data{|response| ...; return hash }
+  # - nil when token was invalid / data was not found
+  def user_data(token, options={})
+    options = options.dup
+    return_raw = options.delete(:raw_response)
+
+    data = begin
+      auth_info(token, options)
+    rescue ServerError
+      return nil if $!.to_s=~/Data not found/
+      raise
+    end
+
+    result = (block_given? ? yield(data) : (return_raw ? data : parse_user_data(data, options)))
+    with_indifferent_access(result)
+  end
+
+  # same data as user_data, but without any kind of post-processing
+  def auth_info(token, options={})
+    data = Api.call("auth_info", options.merge(:token => token))
+    with_indifferent_access(data)
+  end
+
+  # same as for auth_info if Offline Profile Access is enabled,
+  # but can be called at any time and does not need a token / does not expire
+  def get_user_data(identifier, options={})
+    data = Api.call("get_user_data", options.merge(:identifier => identifier))
+    with_indifferent_access(data)
+  end
+
+  # set the users status
+  def set_status(identifier, status, options={})
+    options = options.merge(:identifier => identifier, :status => status)
+    Api.call("set_status", options)
+  rescue ServerError
+    return nil if $!.to_s=~/Data not found/
+    raise
+  end
+
+  # Post an activity update to the user's activity stream.
+  # See more: https://rpxnow.com/docs#api_activity
+  def activity(identifier, activity_options, options={})
+    options = options.merge(:identifier => identifier, :activity => activity_options.to_json)
+    Api.call("activity", options)
+  end
+
+  # maps an identifier to an primary-key (e.g. user.id)
+  def map(identifier, primary_key, options={})
+    Api.call("map", options.merge(:identifier => identifier, :primaryKey => primary_key))
+  end
+
+  # un-maps an identifier to an primary-key (e.g. user.id)
+  def unmap(identifier, primary_key, options={})
+    Api.call("unmap", options.merge(:identifier => identifier, :primaryKey => primary_key))
+  end
+
+  # returns an array of identifiers which are mapped to one of your primary-keys (e.g. user.id)
+  def mappings(primary_key, options={})
+    Api.call("mappings", options.merge(:primaryKey => primary_key))['identifiers']
+  end
+
+  def all_mappings(options={})
+    Api.call("all_mappings", options)['mappings']
+  end
+
+  def contacts(identifier, options={})
+    data = Api.call("get_contacts", options.merge(:identifier => identifier))
+    RPXNow::ContactsCollection.new(data['response'])
+  end
+  alias get_contacts contacts
+
+  # embedded rpx login (via iframe)
+  # options: :width, :height, :language, :flags, :api_version, :default_provider
+  def embed_code(subdomain, url, options={})
+    options = {:width => '400', :height => '240'}.merge(options)
+    <<-EOF
+      <iframe src="#{Api.host(subdomain)}/openid/embed?#{embed_params(url, options)}"
+        scrolling="no" frameBorder="no" style="width:#{options[:width]}px;height:#{options[:height]}px;" id="rpx_now_embed" allowtransparency="allowtransparency">
+      </iframe>
+    EOF
+  end
+
+  # popup window for rpx login
+  # options: :language, :flags, :unobtrusive, :api_version, :default_provider, :html
+  def popup_code(text, subdomain, url, options = {})
+    if options[:unobtrusive]
+      unobtrusive_popup_code(text, subdomain, url, options)
+    else
+      obtrusive_popup_code(text, subdomain, url, options)
+    end
+  end
+
+  # javascript for popup
+  # only needed in combination with popup_code(x,y,z, :unobtrusive => true)
+  def popup_source(subdomain, url, options={})
+    <<-EOF
+      <script src="#{Api.host}/openid/v#{extract_version(options)}/widget" type="text/javascript"></script>
+      <script type="text/javascript">
+        //<![CDATA[
+        $(function () {
+          RPXNOW.token_url = '#{url}';
+          RPXNOW.realm = '#{subdomain}';
+          RPXNOW.overlay = true;
+          #{ "RPXNOW.language_preference = '#{options[:language]}';" if options[:language] }
+          #{ "RPXNOW.default_provider = '#{options[:default_provider]}';" if options[:default_provider] }
+          #{ "RPXNOW.flags = '#{options[:flags]}';" if options[:flags] }
+        });
+        //]]>
+      </script>
+    EOF
+  end
+
+  # url for unobtrusive popup window
+  # options: :language, :flags, :api_version, :default_provider
+  def popup_url(subdomain, url, options={})
+    "#{Api.host(subdomain)}/openid/v#{extract_version(options)}/signin?#{embed_params(url, options)}"
+  end
+
+  def extract_version(options)
+    options[:api_version] || api_version
+  end
+
+  private
+
+  def self.embed_params(url, options)
+    {
+      :token_url => CGI::escape( url ),
+      :language_preference => options[:language],
+      :flags => options[:flags],
+      :default_provider => options[:default_provider]
+    }.map{|k,v| "#{k}=#{v}" if v}.compact.join('&amp;')
+  end
+
+  def self.parse_user_data(response, options)
+    user_data = response['profile']
+    data = {}
+    data[:identifier] = user_data['identifier']
+    data[:email] = user_data['verifiedEmail'] || user_data['email']
+    data[:username] = user_data['preferredUsername'] || data[:email].to_s.sub(/@.*/,'')
+    data[:name] = user_data['displayName'] || data[:username]
+    data[:id] = user_data['primaryKey'] unless user_data['primaryKey'].to_s.empty?
+
+    additional = (options[:additional] || [])
+    additional << :extended if options[:extended]
+    additional.each do |key|
+      data[key] = case key
+      when :raw
+        warn "RPXNow :raw is deprecated, please use :raw_response + e.g. data['raw_response']['profile']['verifiedEmail']"
+        user_data
+      when :raw_response
+        response
+      when :extended
+        response.reject{|k,v| ['profile','stat'].include?(k) }
+      else
+        user_data[key.to_s]
+      end
+    end
+    data
+  end
+
+  def unobtrusive_popup_code(text, subdomain, url, options={})
+    options = options.dup
+    html_options = options.delete(:html) || {}
+    html_options[:class] = "rpxnow #{html_options[:class]}".strip
+    html_options[:href] ||= popup_url(subdomain, url, options)
+    html_options = html_options.sort_by{|k,v|k.to_s}.map{|k,v| %{#{k}="#{v}"}}
+
+    %{<a #{html_options.join(' ')}>#{text}</a>}
+  end
+
+  def obtrusive_popup_code(text, subdomain, url, options = {})
+    unobtrusive_popup_code(text, subdomain, url, options) +
+    popup_source(subdomain, url, options)
+  end
+
+  def with_indifferent_access(hash)
+    hash.respond_to?(:with_indifferent_access) ? hash.with_indifferent_access : hash
+  end
+
+  class ServerError < RuntimeError; end #backwards compatibility / catch all
+  class ApiError < ServerError; end
+  class ServiceUnavailableError < ServerError; end
+end

data/rpx_now.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rpx_now}
+  s.version = "0.6.24"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser"]
+  s.date = %q{2011-02-21}
+  s.email = %q{grosser.michael@gmail.com}
+  s.files = [
+    "CHANGELOG",
+    "Gemfile",
+    "Gemfile.lock",
+    "MIGRATION",
+    "Rakefile",
+    "Readme.md",
+    "VERSION",
+    "certs/ssl_cert.pem",
+    "init.rb",
+    "lib/rpx_now.rb",
+    "lib/rpx_now/api.rb",
+    "lib/rpx_now/contacts_collection.rb",
+    "lib/rpx_now/user_integration.rb",
+    "lib/rpx_now/user_proxy.rb",
+    "rpx_now.gemspec",
+    "spec/fixtures/get_contacts_response.json",
+    "spec/integration/mapping_spec.rb",
+    "spec/rpx_now/api_spec.rb",
+    "spec/rpx_now/contacts_collection_spec.rb",
+    "spec/rpx_now/user_proxy_spec.rb",
+    "spec/rpx_now_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/grosser/rpx_now}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{Helper to simplify RPX Now user login/creation}
+  s.test_files = [
+    "spec/integration/mapping_spec.rb",
+    "spec/rpx_now/api_spec.rb",
+    "spec/rpx_now/contacts_collection_spec.rb",
+    "spec/rpx_now/user_proxy_spec.rb",
+    "spec/rpx_now_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json_pure>, [">= 0"])
+    else
+      s.add_dependency(%q<json_pure>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json_pure>, [">= 0"])
+  end
+end
+

data/spec/fixtures/get_contacts_response.json

@@ -0,0 +1,58 @@
+{
+  "response": {
+    "itemsPerPage": 5,
+    "totalResults": 5,
+    "entry": [
+      {
+        "displayName": "Bob Johnson",
+        "emails": [
+          {
+            "type": "other",
+            "value": "bob@example.com"
+          }
+        ]
+      },
+      {
+        "displayName": "Cindy Smith",
+        "emails": [
+          {
+            "type": "other",
+            "value": "cindy.smith@example.com"
+          }
+        ]
+      },
+      {
+        "displayName": "Fred Williams",
+        "emails": [
+          {
+            "type": "other",
+            "value": "fred.williams@example.com"
+          },
+          {
+            "type": "other",
+            "value": "fred@example.com"
+          }
+        ]
+      },
+      {
+        "emails": [
+          {
+            "type": "other",
+            "value": "j.lewis@example.com"
+          }
+        ]
+      },
+      {
+        "displayName": "Mary Jones",
+        "emails": [
+          {
+            "type": "other",
+            "value": "mary.jones@example.com"
+          }
+        ]
+      }
+    ],
+    "startIndex": 1
+  },
+  "stat": "ok"
+}

data/spec/integration/mapping_spec.rb

@@ -0,0 +1,40 @@
+require 'spec/spec_helper'
+
+describe RPXNow do
+  describe :mapping_integration do
+    before do
+      @k1 = 'http://test.myopenid.com'
+      RPXNow.unmap(@k1, 1)
+      @k2 = 'http://test-2.myopenid.com'
+      RPXNow.unmap(@k2, 1)
+    end
+
+    it "has no mappings when nothing was mapped" do
+      RPXNow.mappings(1).should == []
+    end
+
+    it "unmaps mapped keys" do
+      RPXNow.map(@k2, 1)
+      RPXNow.unmap(@k2, 1)
+      RPXNow.mappings(1).should == []
+    end
+
+    it "maps keys to a primary key and then retrieves them" do
+      RPXNow.map(@k1, 1)
+      RPXNow.map(@k2, 1)
+      RPXNow.mappings(1).sort.should == [@k2,@k1]
+    end
+
+    it "does not add duplicate mappings" do
+      RPXNow.map(@k1, 1)
+      RPXNow.map(@k1, 1)
+      RPXNow.mappings(1).should == [@k1]
+    end
+
+    it "finds all mappings" do
+      RPXNow.map(@k1, 1)
+      RPXNow.map(@k2, 2)
+      RPXNow.all_mappings.sort.should == [["1", ["http://test.myopenid.com"]], ["2", ["http://test-2.myopenid.com"]]]
+    end
+  end
+end

data/spec/rpx_now/api_spec.rb

@@ -0,0 +1,50 @@
+require 'spec/spec_helper'
+
+describe RPXNow::Api do
+  describe 'ssl cert' do
+    it "has an absolute path" do
+      RPXNow::Api::SSL_CERT[0..0].should == File.expand_path( RPXNow::Api::SSL_CERT )[0..0] # start with '/' on *nix, drive letter on win
+    end
+
+    it "exists" do
+      File.read(RPXNow::Api::SSL_CERT).to_s.should_not be_empty
+    end
+  end
+
+  describe :parse_response do
+    it "parses json when status is ok" do
+      response = mock(:code=>'200', :body=>%Q({"stat":"ok","data":"xx"}))
+      RPXNow::Api.send(:parse_response, response)['data'].should == "xx"
+    end
+
+    it "raises when there is a communication error" do
+      response = stub(:code=>'200', :body=>%Q({"err":"wtf","stat":"ok"}))
+      lambda{
+        RPXNow::Api.send(:parse_response,response)
+      }.should raise_error(RPXNow::ApiError)
+    end
+
+    it "raises when service has downtime" do
+      response = stub(:code=>'200', :body=>%Q({"err":{"code":-1},"stat":"ok"}))
+      lambda{
+        RPXNow::Api.send(:parse_response,response)
+      }.should raise_error(RPXNow::ServiceUnavailableError)
+    end
+
+    it "raises when service is down" do
+      response = stub(:code=>'400',:body=>%Q({"stat":"err"}))
+      lambda{
+        RPXNow::Api.send(:parse_response,response)
+      }.should raise_error(RPXNow::ServiceUnavailableError)
+    end
+  end
+
+  describe :request_object do
+    it "converts symbols to string keys" do
+      mock = ''
+      mock.should_receive(:form_data=).with([['symbol', 'value']])
+      Net::HTTP::Post.should_receive(:new).and_return(mock)
+      RPXNow::Api.send(:request_object, 'something', :symbol=>'value')
+    end
+  end
+end

data/spec/rpx_now/contacts_collection_spec.rb

@@ -0,0 +1,32 @@
+require 'spec/spec_helper'
+
+describe RPXNow::ContactsCollection do
+  before do
+    data = JSON.parse(File.read('spec/fixtures/get_contacts_response.json'))['response']
+    @collection = RPXNow::ContactsCollection.new(data)
+  end
+
+  it "behaves like an array" do
+    @collection.size.should == 5
+    @collection[0] = "1"
+    @collection[0].should == "1"
+  end
+
+  it "parses entry to items" do
+    @collection[0]['displayName'].should == "Bob Johnson"
+  end
+
+  it "parses emails to list" do
+    @collection[0]['emails'].should == ["bob@example.com"]
+  end
+
+  it "parses emails to list with multiple emails" do
+    @collection[2]['emails'].should == ["fred.williams@example.com","fred@example.com"]
+  end
+
+  it "holds additional_info" do
+    @collection.additional_info['startIndex'].should == 1
+    @collection.additional_info['itemsPerPage'].should == 5
+    @collection.additional_info['totalResults'].should == 5
+  end
+end

data/spec/rpx_now/user_proxy_spec.rb

@@ -0,0 +1,33 @@
+require 'spec/spec_helper'
+require 'rpx_now/user_integration'
+
+class User
+  include RPXNow::UserIntegration
+
+  def id
+    5
+  end
+end
+
+describe RPXNow::UserProxy do
+  before { @user = User.new }
+
+  it "has a proxy" do
+    @user.rpx.class.should == RPXNow::UserProxy
+  end
+
+  it "has identifiers" do
+    RPXNow.should_receive(:mappings).with(@user.id).and_return(['identifiers'])
+    @user.rpx.identifiers.should == ['identifiers']
+  end
+
+  it "can map" do
+    RPXNow.should_receive(:map).with('identifier', @user.id)
+    @user.rpx.map('identifier')
+  end
+
+  it "can unmap" do
+    RPXNow.should_receive(:unmap).with('identifier', @user.id)
+    @user.rpx.unmap('identifier')
+  end
+end