gitkit-ruby 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    gitkit-ruby (0.0.1)
+      addressable (~> 2.2)
+      httparty (~> 0.8)
+      json (~> 1.4.6)
+      rack (~> 1.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    hoe (2.12.4)
+      rake (~> 0.8)
+    httparty (0.8.1)
+      multi_json
+      multi_xml
+    json (1.4.6)
+    multi_json (1.0.3)
+    multi_xml (0.4.1)
+    rack (1.3.4)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rake (0.9.2)
+    rr (1.0.4)
+    test-unit (1.2.3)
+      hoe (>= 1.5.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gitkit-ruby!
+  rack-test (~> 0.6)
+  rake (~> 0.9)
+  rr (~> 1.0)
+  test-unit (~> 1.2)

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+FileList['tasks/**/*.rake'].each { |task| import task }
+
+"""
+require 'bundle/gem_tasks'
+begin
+  gem 'jeweler', '~> 1.6.4'
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'gitkit-ruby'
+    gem.summary     = 'Rack middleware for Google Identity Toolkit'
+    gem.description = gem.summary
+    gem.email       = 'sqrrrl@gmail.com'
+    gem.homepage    = 'http://code.google.com/p/%s' % gem.name
+    gem.authors     = [ 'Steve Bazyl' ]
+
+    #gem.rubyforge_project = 'gitkit-ruby'
+  end
+
+  Jeweler::GemcutterTasks.new
+
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler -v 1.6.4'
+end
+"""
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/gitkit-ruby.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "google/identity_toolkit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gitkit-ruby"
+  s.version     = Google::IdentityToolkit::VERSION
+  s.authors     = ["Steven Bazyl"]
+  s.email       = ["sqrrrl@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Rack middleware for Google Identity Toolkit}
+  s.description = %q{Rack middleware for Google Identity Toolkit}
+
+  s.rubyforge_project = "gitkit-ruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'rack','~> 1.3'
+  s.add_dependency 'json', '~> 1.4.6'
+  s.add_dependency 'httparty', '~> 0.8'
+  s.add_dependency 'addressable', '~> 2.2'
+  
+  s.add_development_dependency 'rake', '~> 0.9'
+  s.add_development_dependency 'rack-test', '~> 0.6'
+  s.add_development_dependency 'test-unit', '~> 1.2'
+  s.add_development_dependency 'rr', '~> 1.0'
+  
+end

data/lib/google/identity_toolkit.rb

@@ -0,0 +1,298 @@
+require "rack"
+require "json"
+require "google/identity_toolkit/api"
+require "google/identity_toolkit/helpers"
+require "addressable/uri"
+
+module Google
+  CONTENT_TYPE = 'Content-Type'
+  CONTENT_TYPE_HTML = 'text/html'
+  CONTENT_TYPE_JSON = 'application/json'
+  STATUS_SUCCESS = 'success'
+  STATUS_INVALID_EMAIL = 'invalidAssertionEmail'
+  STATUS_ACCOUNT_MISMATCH = 'accountMismatch'
+  
+  ##
+  # Rack middleware for using the Google Identity Kit for federated login
+  # @see http://code.google.com/apis/identitytoolkit/
+  class IdentityToolkit
+    attr_accessor :api_key
+    attr_accessor :path
+    attr_accessor :app
+    attr_accessor :api
+    attr_accessor :callback_url
+    attr_accessor :federated_signup_url
+    attr_accessor :signup_url
+    attr_accessor :home_url
+
+    ##
+    # Creates the Identity toolkit middleware.  Requires defining a block
+    # to configure the API and define callback methods for loading & authenticating
+    # users.
+    #
+    # @example
+    #   use Google::IdentityToolkit, do |toolkit|
+    #     toolkit.api_key = "..."
+    #     def fetch_user(email, assertion = nil)
+    #       # Load the user for the given email, optionally registering
+    #       # the user if assertion is provided and '
+    #     end
+    #
+    #     def password_valid?(email, password)
+    #       # Validates the user id/password
+    #     end
+    #  end
+    def initialize(app, &block)
+      @path = '/_gitkit'
+      @callback_url = nil
+      @app = app
+      instance_eval(&block) if block_given?
+    end
+
+    ##
+    # Static method for fetching the API key from thread-local storage.  Only valid for threads
+    # intercepted by the rack module.  Use by helper methods rendering the login button.
+    #
+    # @return [String] API Key
+    def self.api_key
+      env[:gitkit_api_key]
+    end
+
+    ##
+    # Static method for fetching the current user from thread-local storage.  Only valid for threads
+    # intercepted by the rack module.  Use by helper methods rendering the login button.
+    #
+    # @return [Hash] Hash representing the user
+    def self.current_user
+      env[:gitkit_user]
+    end
+
+    ##
+    # Static method for fetching the callback URL from thread-local storage.  Only valid for threads
+    # intercepted by the rack module.  Use by helper methods rendering the login button.
+    #
+    # @return [Hash] Hash representing the user
+    def self.callback_url
+      env[:gitkit_callback_url]
+    end
+
+    ##
+    # Get (and lazy init) the API client
+    #
+    # @return [Google::IdentityToolkit::Api]
+    #  API client
+    def api
+      @api ||= Google::IdentityToolkit::Api.new(@api_key)
+    end
+
+    ##
+    # Handles web requests for identity toolkit callbacks
+    #
+    # @param [Hash] env 
+    #  Rack request context
+    # @return [Array]
+    #  HTTP response
+    def call(env)
+      request = Rack::Request.new(env)
+      env[:gitkit_api_key] = @api_key
+      env[:gitkit_callback_url] = callback_url(request)
+      env[:gitkit_user] = request.session[:git_user]
+      Thread.current[:gitkit_rack_env] = env
+      begin
+        return @app.call(env) unless request.path == @path
+        case request.params['rp_target']
+          when "callback"
+            body = callback(request)
+            [200, {CONTENT_TYPE => CONTENT_TYPE_HTML}, [body]]
+          when "login"
+            data = login(request)
+            [200, {CONTENT_TYPE => CONTENT_TYPE_JSON}, [data.to_json]]
+          when "userStatus"
+            data = status(request)
+            [200, {CONTENT_TYPE => CONTENT_TYPE_JSON}, [data.to_json]]
+        end
+      ensure
+        Thread.current[:gitkit_rack_env] = nil
+      end
+    end
+
+    ##
+    # Handles IDP responses during login
+    #
+    # @param [Rack::Request] request
+    #  current request
+    # @return [String] 
+    #  HTML boilerplate to close popup & notify parent window
+    def callback(request)
+      render_method = !!request.params['mobile'] ? :build_mobile_html : :build_notify_html
+      begin
+        assertion = api.verify_assertion(request.url, request.body)
+        input_email = request.params['rp_input_email']
+        email = assertion['verifiedEmail']
+        return send(render_method, STATUS_INVALID_EMAIL, {}) if email.nil?
+        return send(render_method, STATUS_ACCOUNT_MISMATCH, {
+            "inputEmail" => input_email,
+            "validatedEmail" => email
+        }) unless input_email.nil? or input_email == email
+
+        user = fetch_user(email, assertion)
+        if user.nil?
+          # Save the assertion for use in signup page 
+          request.session[:gitkit_assertion] = assertion unless session.nil?
+          send(render_method, STATUS_SUCCESS, {
+              "email" => email,
+              "registered" => false,
+              "displayName" => assertion["displayName"],
+              "photoUrl" => assertion["photoUrl"]
+          })
+        else
+          # User exits, login
+          upgrade_user(email)
+          handle_login(user)
+          send(render_method, STATUS_SUCCESS, {
+              "email" => email,
+              "registered" => true,
+              "displayName" => assertion["displayName"],
+              "photoUrl" => assertion["photoUrl"]
+          })
+        end
+      rescue Exception => e
+        send(render_method, 'invalidAssertion', {})
+      end
+    end    
+
+    ##
+    # Handles authentication requests for non-federated users
+    #
+    # @param [Rack::Request] request
+    #  current request
+    # @return [Hash]
+    #   Result of login.  Currently just sets the value of :status in the hash
+    def login(request)
+      user = fetch_user(request.params["email"])
+      if user.nil?
+        {:status => "emailNotExist"}
+      elsif user[:federated]
+        {:status => "federated"}
+      else
+        if password_valid?(request.params["email"], request.params["password"])
+          user = fetch_user(request.params["email"])
+          handle_login(user)
+          {:status => "OK"}
+        else
+          {:status => "passwordError"}
+        end
+      end
+    end
+
+    ##
+    # Checks the status of a user
+    #
+    # @param [Rack::Request] request
+    #  current request
+    # @return [Hash]
+    #  Status of user
+    def status(request)
+      user = fetch_user(request.params["email"])
+      #referrer = request.params["referrer"]
+      { "registered" => !!user,
+        "legacy" => !(user && user[:federated]) }
+    end
+
+    ##
+    # Log the user after either a successful assertion or password validation
+    # @param [Hash]
+    #  User (from find_user)
+    # @param [Rack::Request] request
+    #  Current request
+    def handle_login(user)
+      unless session.nil?
+        request.session[:git_user] = user
+        on_login(user)
+      end
+    end
+    
+    ##
+    # Renders boilerplate HTML for closing popups after login
+    #
+    # @param [String] status
+    #  Status of callback -- either success, or one of the gitkit supported error messages
+    # @param [Hash] data
+    #  user data from assertion if successful login
+    # @return [String] HTML
+    def build_notify_html(status, data)
+      html = <<-EOF
+        <script type='text/javascript' src='https://ajax.googleapis.com/jsapi'></script>
+        <script type='text/javascript'>google.load("identitytoolkit", "1.0", {packages: ["notify"]});</script>
+        <script type='text/javascript'>
+      EOF
+      case status
+      when STATUS_SUCCESS
+        html << "window.google.identitytoolkit.notifyFederatedSuccess(#{data.to_json});"
+      else
+        html << "window.google.identitytoolkit.notifyFederatedError('#{status}', #{data.to_json});"
+      end
+      html << "</script>"
+    end
+
+    ##
+    # Renders boilerplate HTML for non-poup mobile UI
+    #
+    # @param [String] status
+    #  Status of callback -- either success, or one of the gitkit supported error messages
+    # @param [Hash] data
+    #  user data from assertion if successful login
+    # @return [String] HTML
+    def build_mobile_html(status, data)
+      html = "<script type='text/javascript'>"
+      if status == STATUS_SUCCESS
+        if data["registered"]
+          html << "window.location = '#{home_url}';"
+        else
+          target = Addressable::URI.parse(signup_url)
+          target.query_values = target.query_values.merge("email" => data["email"])
+          html << "window.location = '#{target}';"
+        end
+      else
+        target = Addressable::URI.parse(login_url)
+        target.query_values = target.query_values.merge("error" => status)
+        html << "window.location = '#{login_url}';"
+      end
+      html << "</script>"
+    end
+    
+    # Get the callback URL for use in the javascript helpers.
+    #
+    # @param [Rack::Request] request
+    #  current request object
+    # @return [String]
+    #  callback URL for verifying assertions
+    def callback_url(request = nil)
+      return @callback_url unless @callback_url.nil?
+      scheme = request.scheme
+      if (scheme == 'http' && request.port == 80 ||
+          scheme == 'https' && request.port == 443)
+        port = ""
+      else
+        port = ":#{request.port}"
+      end
+      "#{scheme}://#{request.host}#{port}#{request.script_name}#{@path}"
+    end
+    
+    def self.env
+      Thread.current[:gitkit_rack_env]
+    end
+    
+    def env
+      Thread.current[:gitkit_rack_env]
+    end
+      
+    def request
+      Rack::Request.new(env)      
+    end
+    
+    def session
+      request.session
+    end
+  end
+end

data/lib/google/identity_toolkit/api.rb

@@ -0,0 +1,53 @@
+require 'httparty'
+require 'google/identity_toolkit/errors'
+require 'json'
+
+module Google
+  class IdentityToolkit
+
+    ##
+    # Server API for creating login requests & verifying assertions
+    class Api
+      include HTTParty
+      format :json
+      headers  "Content-Type" => "application/json"
+      
+      ##
+      # Initializes the API
+      #
+      # @param [String] api_key
+      #   API key from developer console
+      def initialize(api_key)
+        @api_key = api_key
+      end
+
+      ##
+      # Sends an IDP response for verification, returning an assertion
+      # if the response is valid
+      #
+      # @param [String] request_uri
+      #   URL of the current request
+      # @param [StringIO] body
+      #   Request body (if post)
+      #
+      # @return [Hash]
+      #   Assertion of user identity
+      #
+      # @raise [ApiError]
+      #   if assertion not valid
+      def verify_assertion(request_uri, body=nil)
+        request = {
+          "requestUri" => request_uri
+        }
+        request["postBody"] = body.gets unless body.nil?
+        response = Api.post('https://www.googleapis.com/identitytoolkit/v1/relyingparty/verifyAssertion', 
+          :query => { "key" => @api_key }, :body => request.to_json )
+        raise ApiError.new("Error #{response.code} when verifying the assertion") unless response.code == 200
+        response.parsed_response
+      end
+      
+
+    end
+  end
+
+end

data/lib/google/identity_toolkit/errors.rb

@@ -0,0 +1,11 @@
+module Google
+  class IdentityToolkit
+    ##
+    # General exception for failed API calls when verifiying assertions
+    class ApiError < StandardError
+      def initialize(s)
+        super(s)
+      end
+    end
+  end
+end

data/lib/google/identity_toolkit/helpers.rb

@@ -0,0 +1,64 @@
+require 'addressable/uri'
+
+module Google
+  class IdentityToolkit
+    module Helpers
+
+      ##
+      # Generate javascript for configuring the identity toolkit button
+      #
+      # @param [String] element_id
+      #   Id of element that will contain the login button
+      # @param [Hash] options
+      #   Configuration options
+      # @option options [String] :api_key
+      #   APIKey from developer console
+      # @option options [String] :company_name
+      #   Name of site to display on login pages
+      # @option options [String] :base_url
+      #
+      # @return [String] Block of javascript (must be wrapped in <script> tag)
+
+      def account_chooser(element_id, options = {})
+        callback_url = Addressable::URI.parse(options[:callback_url] || Google::IdentityToolkit.callback_url)
+        params = callback_url.query_values || {}
+        callback_url.query_values = params.merge("mobile" => "1") if options[:mobile]
+        js = <<-EOF
+          window.google.identitytoolkit.setConfig({
+            developerKey: "#{options[:api_key] || Google::IdentityToolkit.api_key}",
+            companyName: "#{options[:site_name]}",
+            callbackUrl: "#{callback_url}",
+            userStatusUrl: "#{callback_url}",
+            loginUrl: "#{callback_url}",
+            federatedSignupUrl: "#{options[:federated_signup_url] || options[:signup_url] || '/signup' }",
+            signupUrl: "#{options[:signup_url] || '/signup'}",
+            homeUrl: "#{options[:home_url] || '/' }",
+            logoutUrl: "#{options[:logout_url] || '/logout'}",
+            realm: "#{options[:realm]}",
+            language: "#{options[:language] || 'en'}",
+            idps: ["Gmail", "AOL", "Hotmail", "Yahoo"],
+            tryFederatedFirst: #{options[:try_federated_first] || false},
+            useCachedUserStatus: #{options[:use_cached_status] || false}
+          });
+          $('#{element_id}').accountChooser();
+        EOF
+      end
+
+      def show_current_user(options={})
+        js = ""
+        user = options[:user] || Google::IdentityToolkit.current_user
+        if user
+          js = <<-EOF
+          window.google.identitytoolkit.updateSavedAccount({
+            email: '#{user[:email]}',
+            displayName: '#{user[:display_name]}',
+            photoUrl: '#{user[:photo_url]}'
+          });
+          window.google.identitytoolkit.showSavedAccount('#{user[:email]}');
+          EOF
+        end
+        js
+      end
+    end
+  end
+end

data/lib/google/identity_toolkit/version.rb

@@ -0,0 +1,5 @@
+module Google
+  class IdentityToolkit
+    VERSION = "0.0.1"
+  end
+end

data/tasks/test.rake

@@ -0,0 +1,14 @@
+begin
+  require 'rake/testtask'
+
+  desc "Run basic tests"
+  Rake::TestTask.new("test") { |t|
+    t.pattern = 'test/*_test.rb'
+    t.verbose = true
+    t.warning = true
+  }
+rescue LoadError
+  task :yard do
+    abort 'testunit is not available. In order to run yard, you must: gem install testunit'
+  end
+end

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/test/gitkit_test.rb

@@ -0,0 +1,115 @@
+$: << (File.dirname(__FILE__) + '/../lib')
+
+require "rr"
+require "test/unit"
+require 'rack/test'
+require "google/identity_toolkit"
+
+module MockCallbacks
+  def fetch_user(email, assertion = nil)
+    return {"verifiedEmail" => email} if email.start_with?("exist") || email.start_with?("unregistered")
+  end
+
+  def password_valid?(email, password)
+    "ok" == password
+  end
+  
+  def upgrade_user(user)
+  end
+  
+  def on_login(user)
+  end
+end
+
+class GITKit_Test < Test::Unit::TestCase
+  include Rack::Test::Methods
+  include RR::Adapters::TestUnit
+  
+  attr_accessor :app
+  
+  def setup
+    inner_app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['hello']] }
+    @app = Google::IdentityToolkit.new(inner_app) do |git|
+      git.api_key = "AIzaSyBs1gLwB1_QZ-EXgFqBrrLY1MPXzB3G6ZU"
+      extend MockCallbacks
+    end    
+  end
+
+  def teardown
+    # Do nothing
+  end
+
+  def test_passthrough
+    get '/test'
+    assert_equal 'hello', last_response.body
+  end
+
+  def test_valid_login
+    post '/_gitkit', "rp_target" => "login", "email" => "exists@bar.com", "password" => "ok"
+    data = JSON.parse(last_response.body)
+    assert_equal("OK", data["status"])
+  end
+
+  def test_invalid_login
+    post '/_gitkit', "rp_target" => "login", "email" => "exists@bar.com", "password" => "badpassword"
+    data = JSON.parse(last_response.body)
+    assert_equal("passwordError", data["status"])
+  end
+
+  def test_user_exists
+    post '/_gitkit', "rp_target" => "userStatus", "email" => "exists@foo.com"
+    data = JSON.parse(last_response.body)
+    assert_equal(true, data["registered"])
+  end
+
+  def test_user_not_exists
+    post '/_gitkit', "rp_target" => "userStatus", "email" => "nobody@foo.com"
+    data = JSON.parse(last_response.body)
+    assert_equal(false, data["registered"])
+  end
+
+  def test_callback_registered_user
+    mock(@app.api).verify_assertion(is_a(String), anything) {
+      { "kind" => "identitytoolkit#relyingparty",
+        "identifier" => "12345",
+        "authority" => "google.com",
+        "verifiedEmail" => "existing@foo.com",
+        "firstName" => "Test",
+        "lastName" => "User",
+        "fullName" => "Test User",
+        "nickName" => "test",
+        "language" => "en",
+        "timeZone" => "PST" }
+    }
+    post '/_gitkit?rp_target=callback', "some long assertion...."
+    assert_equal(200, last_response.status)
+    assert_match(/.*"registered":true.*/, last_response.body)
+  end
+
+  def test_callback_unregistered_user
+    mock(@app.api).verify_assertion(is_a(String), anything) {
+      { "kind" => "identitytoolkit#relyingparty",
+        "identifier" => "12345",
+        "authority" => "google.com",
+        "verifiedEmail" => "new@foo.com",
+        "firstName" => "Test",
+        "lastName" => "User",
+        "fullName" => "Test User",
+        "nickName" => "test",
+        "language" => "en",
+        "timeZone" => "PST" }
+    }
+    post '/_gitkit?rp_target=callback', "some long assertion..."
+    assert_equal(200, last_response.status)
+    assert_match(/.*"registered":false.*/, last_response.body)
+  end
+
+  def test_callback_invalid_response
+    mock(@app.api).verify_assertion(is_a(String), anything) {
+      raise ApiError("Invalid assertion") 
+    }
+    post '/_gitkit?rp_target=callback', "garbage"
+    assert_equal(200, last_response.status)
+    assert_match(/.*notifyFederatedError.*/, last_response.body)
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: gitkit-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Steven Bazyl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-16 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70358498379620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70358498379620
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70358498378900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70358498378900
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &70358498377960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70358498377960
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: &70358498376820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70358498376820
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70358498375600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *70358498375600
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70358498373840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70358498373840
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &70358498371760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: *70358498371760
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &70358498370780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70358498370780
+description: Rack middleware for Google Identity Toolkit
+email:
+- sqrrrl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- VERSION
+- gitkit-ruby.gemspec
+- lib/google/identity_toolkit.rb
+- lib/google/identity_toolkit/api.rb
+- lib/google/identity_toolkit/errors.rb
+- lib/google/identity_toolkit/helpers.rb
+- lib/google/identity_toolkit/version.rb
+- tasks/test.rake
+- tasks/yard.rake
+- test/gitkit_test.rb
+homepage: ''
+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'
+      segments:
+      - 0
+      hash: 442708502916154574
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 442708502916154574
+requirements: []
+rubyforge_project: gitkit-ruby
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Rack middleware for Google Identity Toolkit
+test_files:
+- test/gitkit_test.rb