Empact-rpx_now 0.7.0

data/init.rb

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

data/lib/rpx_now.rb

@@ -0,0 +1,163 @@
+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 :ssl
+  self.api_version = 2
+  self.ssl = true
+
+  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={})
+    begin
+      data = Api.call("auth_info", options.merge(:token => token))
+      result = (block_given? ? yield(data) : parse_user_data(data, options))
+      result.respond_to?(:with_indifferent_access) ? result.with_indifferent_access : result
+    rescue ServerError
+      return nil if $!.to_s=~/Data not found/
+      raise
+    end
+  end
+
+  # set the users status
+  def set_status(identifier, status, options={})
+    options = options.merge(:identifier => identifier, :status => status)
+    data = 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;">
+      </iframe>
+    EOF
+  end
+
+  # popup window for rpx login
+  # options: :language, :flags, :unobtrusive, :api_version, :default_provider
+  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[
+        RPXNOW.token_url = '#{url}';
+        RPXNOW.realm = '#{subdomain}';
+        RPXNOW.overlay = true;
+        RPXNOW.ssl = #{ssl};
+        #{ "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?
+    (options[:additional] || []).each do |key|
+      if key == :raw
+        data[key] = user_data
+      else
+        data[key] = user_data[key.to_s]
+      end
+    end
+    data
+  end
+
+  def unobtrusive_popup_code(text, subdomain, url, options={})
+    %Q(<a class="rpxnow" href="#{popup_url(subdomain, url, options)}">#{text}</a>)
+  end
+
+  def obtrusive_popup_code(text, subdomain, url, options = {})
+    unobtrusive_popup_code(text, subdomain, url, options) +
+    popup_source(subdomain, url, options)
+  end
+
+  class ServerError < RuntimeError; end #backwards compatibility / catch all
+  class ApiError < ServerError; end
+  class ServiceUnavailableError < ServerError; end
+end

data/lib/rpx_now/api.rb

@@ -0,0 +1,81 @@
+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
+    HOST = 'rpxnow.com'
+    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(realm=nil)
+      protocol = RPXNow.ssl ? 'https' : 'http'
+      domain =
+        if realm.nil?
+          Api::HOST
+        elsif realm.include?('.')
+          realm
+        else
+          "#{realm}.#{Api::HOST}"
+        end
+      "#{protocol}://#{domain}"
+    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(HOST, 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/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,89 @@
+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 :host do
+    after do
+      RPXNow.ssl = true
+    end
+
+    context "when the realm is a domain" do
+      it "returns the domain itself" do
+        RPXNow::Api.host("login.example.com").should == 'https://login.example.com'
+      end
+
+      it "honors the ssl setting" do
+        RPXNow.ssl = false
+        RPXNow::Api.host("login.example.com").should == 'http://login.example.com'
+      end
+    end
+
+    context "when the realm is a subdomain" do
+      it "returns the qualified rpx domain" do
+        RPXNow::Api.host("example").should == 'https://example.rpxnow.com'
+      end
+
+      it "honors the ssl setting" do
+        RPXNow.ssl = false
+        RPXNow::Api.host("example").should == 'http://example.rpxnow.com'
+      end
+    end
+
+    context "when no realm is provided" do
+      it "returns the rpx domain" do
+        RPXNow::Api.host.should == 'https://rpxnow.com'
+      end
+
+      it "honors the ssl setting" do
+        RPXNow.ssl = false
+        RPXNow::Api.host.should == 'http://rpxnow.com'
+      end
+    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