databasedotcom-oauth2 0.1.7

data/.gitignore

@@ -0,0 +1,2 @@
+notes.txt
+databasedotcom-oauth2-0.0.1.gem

data/Gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in omniauth-salesforce.gemspec
+gemspec
+
+group :development, :test do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-bundler'
+  gem 'rb-fsevent'
+  gem 'growl'
+end

data/Gemfile.lock

@@ -0,0 +1,81 @@
+PATH
+  remote: .
+  specs:
+    databasedotcom-oauth2 (0.0.5)
+      addressable
+      databasedotcom
+      oauth2
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.8)
+    crack (0.3.1)
+    databasedotcom (1.3.0)
+      json
+      multipart-post (~> 1.1)
+    diff-lcs (1.1.3)
+    faraday (0.8.1)
+      multipart-post (~> 1.1)
+    ffi (1.0.11)
+    growl (1.0.3)
+    guard (1.1.1)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-bundler (0.1.3)
+      bundler (>= 1.0.0)
+      guard (>= 0.2.2)
+    guard-rspec (1.0.0)
+      guard (>= 1.1)
+    httpauth (0.1)
+    json (1.7.3)
+    listen (0.4.4)
+      rb-fchange (~> 0.0.5)
+      rb-fsevent (~> 0.9.1)
+      rb-inotify (~> 0.8.8)
+    multi_json (1.3.6)
+    multipart-post (1.1.5)
+    oauth2 (0.7.1)
+      faraday (~> 0.8)
+      httpauth (~> 0.1)
+      multi_json (~> 1.0)
+      rack (~> 1.4)
+    rack (1.4.1)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rb-fchange (0.0.5)
+      ffi
+    rb-fsevent (0.9.1)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    thor (0.15.2)
+    webmock (1.8.7)
+      addressable (>= 2.2.7)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  databasedotcom-oauth2!
+  growl
+  guard
+  guard-bundler
+  guard-rspec
+  rack-test
+  rb-fsevent
+  rspec (~> 2.7)
+  simplecov
+  webmock

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+# databasedotcom-oauth2
+
+Rack Middleware for OAuth2 authentication against, and interaction with salesforce.com via the databasedotcom gem.  
+
+### Who's it for?
+
+RubyDevelopers of 
+Whereas OmniAuth only provides authentication, this Rack Middleware assumes you lso instantiates a Databasedotcom::Client while providing an 
+
+ authentication and  you need to query or manipulate salesforce.com data in addition to authentication.
+
+### Benefits:
+
+* Hides OAuth2 hand-shake complexity against multiple salesforce.com endpoints (prod vs sandbox) including support for My Domain.
+* Configurable/override-able options for scope, display, immediate
+* OAuth2 Token encrypted and stored in session, supports any Rack:Session type - Cookie, Pool, etc.
+* Materializes Databasedotcom::Client from token upon each request
+* Databasedotcom::OAuth2::Helpers mixin provides convenience methods client, me, etc.
+
+## Demos
+
+<a href="https://db-oauth2-sinatra-basic.herokuapp.com" target="_blank">Sinatra Basic</a><a href="https://github.com/richardvanhook/databasedotcom-oauth2-sinatra-basic" target="_blank">(source)</a>
+
+<a href="https://db-oauth2-sinatra-jqm.herokuapp.com" target="_blank">Sinatra showing authentication options along with JQuery Mobile</a><a href="https://github.com/richardvanhook/databasedotcom-oauth2-sinatra-jqm" target="_blank">(source)</a>
+
+## Usage
+
+### Required 
+
+`:token_encryption_key` & `:endpoints` are required.  databasedotcom-oauth2 encrypts oauth2 token using `:token_encryption_key` and stores it in rack.session for further use.  `:endpoints` defines the server endpoints to be available; multiple can be specified but at least one is required.  
+
+```ruby
+use Databasedotcom::OAuth2::WebServerFlow, 
+  :token_encryption_key => TOKEN_ENCRYPTION_KEY,
+  :endpoints            => {"login.salesforce.com" => {:keys => CLIENT_ID, :secret => CLIENT_SECRET}}
+```
+
+### Multiple Endpoints 
+
+```ruby
+use Databasedotcom::OAuth2::WebServerFlow, 
+  :endpoints            => {"login.salesforce.com" => {:keys => CLIENT_ID1, :secret => CLIENT_SECRET1},
+                            "test.salesforce.com"  => {:keys => CLIENT_ID2, :secret => CLIENT_SECRET2}}
+```
+### Authentication Options
+```ruby
+use Databasedotcom::OAuth2::WebServerFlow, 
+  :scope                => "full",  #default is "id api refresh_token"
+  :display              => "touch", #default is "page"
+  :immediate            => true     #default is false
+  :scope_override       => true,    #default is false
+  :display_override     => true,    #default is false
+  :immediate_override   => true,    #default is false
+```
+
+## Parameters
+
+### `:endpoints`
+
+
+
+### `:token_encryption_key`
+
+It's uber important that `:token_encryption_key` is sufficiently strong.  To generate a sufficiently strong key, run following:
+
+    $ ruby -ropenssl -rbase64 -e "puts Base64.strict_encode64(OpenSSL::Random.random_bytes(16).to_str)"
+
+Then, in your code, decrypt prior using:
+
+```ruby
+Base64.strict_decode64(TOKEN_ENCRYPTION_KEY)
+```
+
+## Resources
+
+* [Article: Digging Deeper into OAuth 2.0 on Force.com](http://wiki.developerforce.com/index.php/Digging_Deeper_into_OAuth_2.0_on_Force.com)

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new
+
+desc 'Run specs'
+task :default => :spec

data/databasedotcom-oauth2.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/databasedotcom-oauth2/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Richard Vanhook"]
+  gem.email         = ["rvanhook@salesforce.com"]
+  gem.description   = %q{OAuth2 Rack Middleware for database.com/salesforce.com.}
+  gem.summary       = %q{OAuth2 Rack Middleware for database.com/salesforce.com.}
+  gem.homepage      = "https://github.com/richardvanhook/databasedotcom-oauth2"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "databasedotcom-oauth2"
+  gem.require_paths = ["lib"]
+  gem.version       = Databasedotcom::OAuth2::VERSION
+
+  gem.add_dependency 'addressable'
+  gem.add_dependency 'hashie'
+  gem.add_dependency 'gibberish'
+  gem.add_dependency 'databasedotcom'
+  gem.add_dependency 'oauth2'
+
+  gem.add_development_dependency 'rspec', '~> 2.7'
+  gem.add_development_dependency 'rack-test'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'webmock'
+end

data/lib/databasedotcom-oauth2/version.rb

@@ -0,0 +1,5 @@
+module Databasedotcom
+  module OAuth2
+    VERSION    = "0.1.7"
+  end
+end

data/lib/databasedotcom-oauth2.rb

@@ -0,0 +1,366 @@
+require "cgi"
+require "base64"
+require "openssl"
+require "addressable/uri"
+require "hashie"
+require "gibberish"
+require "databasedotcom"
+require "oauth2"
+
+module OAuth2
+  class AccessToken
+    attr_accessor :client
+  end
+end
+
+module Databasedotcom
+  
+  class Client
+    def self.from_token(token, api_version)
+      client = nil
+      unless token.nil?
+        client = self.new({
+          :client_id     => token.client.id, 
+          :client_secret => token.client.secret, 
+          :host          => token.client.site
+        })
+        m = token["id"].match(/\/id\/([^\/]+)\/([^\/]+)$/)
+        client.org_id        = m[1] rescue nil
+        client.user_id       = m[2] rescue nil
+        client.version       = api_version
+        client.instance_url  = token.client.site
+        client.oauth_token   = token.token
+        client.refresh_token = token.refresh_token
+      end
+      client
+    end
+
+    def org_id=(val)
+      @org_id = val
+    end
+
+    def user_id=(val)
+      @user_id = val
+    end
+
+  end
+
+  module OAuth2
+    TOKEN_KEY  = "databasedotcom.token"
+    CLIENT_KEY = "databasedotcom.client"
+    
+    module Helpers
+      def client
+        env['databasedotcom.client']
+      end
+
+      def token
+        env['databasedotcom.token']
+      end
+
+    	def unauthenticated?
+    	  client.nil?
+  	  end
+
+    	def authenticated?
+    	  !unauthenticated?
+    	end
+    	
+    	def me
+    	  @me ||= ::Hashie::Mash.new(Databasedotcom::Chatter::User.find(client, "me").raw_hash)
+    	  #@me.organization_id
+  	  end
+    end
+
+    class WebServerFlow
+
+      def initialize(app, options = nil)
+        @app = app       
+        unless options.nil?
+          @endpoints            = self.class.sanitize_endpoints(options[:endpoints])
+          @token_encryption_key = options[:token_encryption_key]
+          @path_prefix          = options[:path_prefix]
+          @on_failure           = options[:on_failure]
+          @scope                = options[:scope]
+          @display              = options[:display]
+          @immediate            = options[:immediate]
+          @scope_override       = options[:scope_override]     || false
+          @display_override     = options[:display_override]   || false
+          @immediate_override   = options[:immediate_override] || false
+          @api_version          = options[:api_version]        || "24.0"
+        end
+
+        fail "\n\ndatabasedotcom-oauth2 initialization error!  :endpoints parameter " \
+          + "is invalid.  Do something like this:\n\nuse Databasedotcom::OAuth2::Web" \
+          + "ServerFlow, :endpoints => {\"login.salesforce.com\" => { :key => CLIENT" \
+          + "_ID_FROM_DATABASEDOTCOM, :secret => CLIENT_SECRET_FROM_DATABASEDOTCOM }" \
+          + "}\n\n"                                                                   \
+          if !@endpoints.is_a?(Hash) || @endpoints.empty?
+            
+        fail "\n\ndatabasedotcom-oauth2 initialization error!  :token_encryption_key " \
+          + "is invalid.  Do something like this:\n\nuse Databasedotcom::OAuth2::WebS" \
+          + "erverFlow, :token_encryption_key => YOUR_VERY_LONG_VERY_RANDOM_SECRET_KE" \
+          + "Y_HERE\n\nTo generate a sufficiently long random key, use following comm" \
+          + "and:\n\n$ ruby -ropenssl -rbase64 -e \"puts Base64.strict_encode64(OpenS" \
+          + "SL::Random.random_bytes(16).to_str)\"\n\n"                                \
+          if @token_encryption_key.nil? || @token_encryption_key.size < 16
+            
+        @path_prefix = "/auth/salesforce" unless @path_prefix.is_a?(String) && !@path_prefix.strip.empty?
+        @on_failure = nil unless @on_failure.is_a?(Proc)
+      end                
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+        @env = env
+        begin
+          return authorize_call if on_authorize_path?
+          return callback_call  if on_callback_path?
+          materialize_token_and_client_from_session_if_present
+        rescue Exception => e
+          self.class._log_exception(e)
+          if @on_failure.nil?
+            new_path = Addressable::URI.parse(@path_prefix + "/failure")
+            new_path.query_values={:message => e.message, :state => request.params['state']}
+            return [302, {'Location' => new_path.to_s, 'Content-Type'=> 'text/html'}, []]
+          else
+            return @on_failure.call(env,e)
+          end
+        end
+        @app.call(env)
+      end
+
+      private
+
+      def on_authorize_path?
+        on_path?(@path_prefix)
+      end
+
+      def authorize_call
+        #determine endpoint via param; but if blank, use default
+        endpoint = request.params["endpoint"] #get endpoint from http param
+        keys     = @endpoints[endpoint]       #if endpoint not found, default will be used
+        endpoint = @endpoints.invert[keys]    #re-lookup endpoint in case original param was bogus
+        mydomain = self.class.sanitize_mydomain(request.params["mydomain"])
+
+        #add endpoint to relay state so callback knows which keys to use
+        request.params["state"] ||= "/"
+        state = Addressable::URI.parse(request.params["state"])
+        state.query_values={} unless state.query_values
+        state.query_values= state.query_values.merge({:endpoint => endpoint})
+        
+        #build params hash to be passed to ouath2 authorize redirect url
+        auth_params = {
+          :redirect_uri  => "#{full_host}#{@path_prefix}/callback",
+          :state         => state.to_s
+        }
+        auth_params[:scope]     = @scope     unless @scope.nil? || @scope.strip.empty?
+        auth_params[:display]   = @display   unless @display.nil?
+        auth_params[:immediate] = @immediate unless @immediate.nil?
+        
+        #overrides
+        overrides = {}
+        if @scope_override
+          scope = (self.class.param_repeated(request.url, :scope) || []).join(" ")
+          overrides[:scope] = scope unless scope.nil? || scope.strip.empty?
+        end
+        overrides[:display]   = request.params["display"]   unless !@display_override   || request.params["display"].nil?
+        overrides[:immediate] = request.params["immediate"] unless !@immediate_override || request.params["immediate"].nil?
+        auth_params.merge!(overrides)
+        
+        #do redirect
+        redirect client(mydomain || endpoint, keys[:key], keys[:secret]).auth_code.authorize_url(auth_params)
+      end
+      
+      def on_callback_path?
+        on_path?(@path_prefix + "/callback")
+      end
+
+      def callback_call
+        #check for error
+        callback_error         = request.params["error"]         
+        callback_error_details = request.params["error_description"]
+        fail "#{callback_error} #{callback_error_details}" unless callback_error.nil? || callback_error.strip.empty? 
+                
+        #grab authorization code
+        code = request.params["code"]
+        #grab and remove endpoint from relay state
+        #upon successful retrieval of token, state is url where user will be redirected to
+        request.params["state"] ||= "/"
+        state = Addressable::URI.parse(request.params["state"])
+        state.query_values= {} if state.query_values.nil?
+        state_params = state.query_values.dup
+        endpoint = state_params.delete("endpoint")
+        keys = @endpoints[endpoint]
+        state.query_values= state_params
+        state = state.to_s
+        state.sub!(/\?$/,"") unless state.nil?
+
+        #do callout to retrieve token
+        access_token = client(endpoint, keys[:key], keys[:secret]).auth_code.get_token(code, 
+          :redirect_uri => "#{full_host}#{@path_prefix}/callback")
+        access_token.options[:mode]       = :query
+        access_token.options[:param_name] = :oauth_token
+        access_token.options[:endpoint]   = endpoint
+        access_token.client = nil
+        
+        #populate session with serialized, encrypted token
+        #will be used later to materialize actual token and databasedotcom client handle
+        set_session_token(encrypt(access_token))
+        redirect state.to_str
+      end
+
+      def materialize_token_and_client_from_session_if_present
+        access_token = decrypt(session_token) unless session_token.nil? rescue nil
+        unless access_token.nil?
+          instance_url = access_token.params["instance_url"]
+          endpoint = access_token.options[:endpoint]
+          keys = @endpoints[endpoint]
+          access_token.client = client(instance_url, keys[:key], keys[:secret])
+          unless keys.nil?
+            @env[TOKEN_KEY]  = access_token
+            @env[CLIENT_KEY] = ::Databasedotcom::Client.from_token(@env[TOKEN_KEY],@api_version)
+          end
+        end
+      end
+      
+      def session
+        @env["rack.session"] ||= {} #in case session is nil
+        @env["rack.session"]
+      end
+
+      def session_token
+        session[TOKEN_KEY]
+      end
+
+      def set_session_token(value)
+        session[TOKEN_KEY] = value
+      end
+
+      def aes
+        Gibberish::AES.new(@token_encryption_key)
+      end
+
+      def encrypt(data)
+        aes.encrypt(Marshal.dump(data))
+      end
+
+      def decrypt(data)
+        Marshal.load(aes.decrypt(data))
+      end
+
+      def on_path?(path)
+        current_path.casecmp(path) == 0
+      end
+
+      def current_path
+        request.path_info.downcase.sub(/\/$/,'')
+      end
+
+      def query_string
+        request.query_string.empty? ? "" : "?#{request.query_string}"
+      end
+
+      def request
+        @request ||= Rack::Request.new(@env)
+      end
+      
+      def full_host
+        full_host = ENV['ORIGIN']
+        if full_host.nil? || full_host.strip.empty?
+          full_host = URI.parse(request.url.gsub(/\?.*$/,''))
+          full_host.path = ''
+          full_host.query = nil
+          #sometimes the url is actually showing http inside rails because the other layers (like nginx) have handled the ssl termination.
+          full_host.scheme = 'https' if(request.env['HTTP_X_FORWARDED_PROTO'] == 'https')          
+          full_host = full_host.to_s
+        end
+        full_host
+      end
+      
+      def client(site, client_id, client_secret)
+        ::OAuth2::Client.new(
+           client_id, 
+           client_secret, 
+           :site          => "https://#{self.class.parse_domain(site)}",
+           :authorize_url => '/services/oauth2/authorize',
+           :token_url     => '/services/oauth2/token'
+        )
+      end
+      
+      def redirect(uri)
+        r = Rack::Response.new
+        r.write("Redirecting to #{uri}...")
+        r.redirect(uri)
+        r.finish
+      end
+      
+      class << self
+
+        def _log_exception(exception)
+          STDERR.puts "\n\n#{exception.class} (#{exception.message}):\n    " +
+            exception.backtrace.join("\n    ") +
+            "\n\n"
+        end
+
+        def sanitize_mydomain(mydomain)
+            mydomain = parse_domain(mydomain)
+            mydomain = nil unless mydomain.nil? || !mydomain.strip.empty?
+            mydomain = mydomain.split(/\.my\.salesforce\.com/).first + ".my.salesforce.com" unless mydomain.nil?
+            mydomain
+        end
+
+        def sanitize_endpoints(endpoints = nil)
+          endpoints = {} unless endpoints.is_a?(Hash)
+          endpoints = endpoints.dup
+          endpoints.keep_if do |key,value| 
+            value.is_a?(Hash)       &&
+            value.has_key?(:key)    && 
+            value.has_key?(:secret) &&
+            !value[:key].nil?       && 
+            !value[:secret].nil?    && 
+            !value[:key].empty?     && 
+            !value[:secret].empty?
+          end
+          #set random default if default isn't already populated
+          if !endpoints.empty? && endpoints.default.nil?
+            endpoints.default = endpoints[endpoints.keys.first]
+          end
+          endpoints
+        end
+
+        def parse_domain(url = nil)
+          unless url.nil?
+            url = "https://" + url if (url =~ /http[s]?:\/\//).nil?
+            begin
+              url = Addressable::URI.parse(url)
+            rescue Addressable::URI::InvalidURIError
+              url = nil
+            end
+            url = url.host unless url.nil?
+            url.strip! unless url.nil?
+          end
+          url = nil if url && url.strip.empty?
+          url
+        end
+
+        def param_repeated(url = nil, param_name = nil)
+          return_value = nil
+          unless url.nil? || url.strip.empty? || param_name.nil?
+            url = Addressable::URI.parse(url)
+            param_name = param_name.to_s if param_name.is_a?(Symbol)
+            query_values = url.query_values(:notation => :flat_array)
+            unless query_values.nil? || query_values.empty?
+              return_value = query_values.select{|param| param.is_a?(Array) && param.size >= 2 && param[0] == param_name}.collect{|param| param[1]}
+            end
+          end
+          return_value
+        end
+
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: databasedotcom-oauth2
+version: !ruby/object:Gem::Version
+  version: 0.1.7
+  prerelease: 
+platform: ruby
+authors:
+- Richard Vanhook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gibberish
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: databasedotcom
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: OAuth2 Rack Middleware for database.com/salesforce.com.
+email:
+- rvanhook@salesforce.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- databasedotcom-oauth2.gemspec
+- lib/databasedotcom-oauth2.rb
+- lib/databasedotcom-oauth2/version.rb
+homepage: https://github.com/richardvanhook/databasedotcom-oauth2
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: OAuth2 Rack Middleware for database.com/salesforce.com.
+test_files: []