oa-core 0.2.3 → 0.2.4

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format=nested
+--backtrace

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+--markup-provider maruku
+-
+LICENSE

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+task :test => :spec

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/oa-core.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../../omniauth/lib/omniauth/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.add_development_dependency 'simplecov', '~> 0.4'
+  gem.add_development_dependency 'rack-test', '~> 0.5'
+  gem.add_development_dependency 'rake', '~> 0.8'
+  gem.add_development_dependency 'rspec', '~> 2.5'
+  gem.add_development_dependency 'yard', '~> 0.6'
+  gem.name = 'oa-core'
+  gem.version = Omniauth::VERSION.dup
+  gem.summary = %q{HTTP Basic strategies for OmniAuth.}
+  gem.description = %q{HTTP Basic strategies for OmniAuth.}
+  gem.email = ['michael@intridea.com', 'sferik@gmail.com']
+  gem.homepage = 'http://github.com/intridea/omniauth'
+  gem.authors = ['Michael Bleigh', 'Erik Michaels-Ober']
+  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.require_paths = ['lib']
+  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6') if gem.respond_to? :required_rubygems_version=
+end

data/spec/omniauth/builder_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe OmniAuth::Builder do
+  describe '#provider' do
+    it 'should translate a symbol to a constant' do
+      OmniAuth::Strategies.should_receive(:const_get).with('MyStrategy').and_return(Class.new)
+      OmniAuth::Builder.new(nil) do
+        provider :my_strategy
+      end
+    end
+
+    it 'should also just accept a class' do
+      class ::ExampleClass; end
+
+      lambda{ OmniAuth::Builder.new(nil) do
+        provider ::ExampleClass
+      end }.should_not raise_error
+    end
+  end
+end

data/spec/omniauth/core_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe OmniAuth do
+  describe '.strategies' do
+    it 'should increase when a new strategy is made' do
+      lambda{ class ExampleStrategy
+        include OmniAuth::Strategy
+      end }.should change(OmniAuth.strategies, :size).by(1)
+      OmniAuth.strategies.last.should == ExampleStrategy
+    end
+  end
+  
+  context 'configuration' do
+    it 'should be callable from .configure' do
+      OmniAuth.configure do |c|
+        c.should be_kind_of(OmniAuth::Configuration)
+      end
+    end
+    
+    before do
+      @old_path_prefix = OmniAuth.config.path_prefix
+      @old_on_failure  = OmniAuth.config.on_failure
+    end
+    
+    after do
+      OmniAuth.configure do |config|
+        config.path_prefix = @old_path_prefix
+        config.on_failure  = @old_on_failure
+      end
+    end
+    
+    it 'should be able to set the path' do
+      OmniAuth.configure do |config|
+        config.path_prefix = '/awesome'
+      end
+      
+      OmniAuth.config.path_prefix.should == '/awesome'
+    end
+    
+    it 'should be able to set the on_failure rack app' do
+      OmniAuth.configure do |config|
+        config.on_failure do
+          'yoyo'
+        end
+      end
+      
+      OmniAuth.config.on_failure.call.should == 'yoyo'
+    end
+  end
+  
+  describe '::Utils' do
+    describe '.deep_merge' do
+      it 'should combine hashes' do
+        OmniAuth::Utils.deep_merge({'abc' => {'def' => 123}}, {'abc' => {'foo' => 'bar'}}).should == {
+          'abc' => {'def' => 123, 'foo' => 'bar'}
+        }
+      end
+    end
+    
+    describe '.camelize' do
+      it 'should work on normal cases' do
+        {
+          'some_word' => 'SomeWord',
+          'AnotherWord' => 'AnotherWord',
+          'one' => 'One',
+          'three_words_now' => 'ThreeWordsNow'
+        }.each_pair{ |k,v| OmniAuth::Utils.camelize(k).should == v }
+      end
+      
+      it 'should work in special cases' do
+        {
+          'oauth' => "OAuth",
+          'openid' => 'OpenID',
+          'open_id' => 'OpenID'
+        }.each_pair{ |k,v| OmniAuth::Utils.camelize(k).should == v}
+      end
+    end
+  end
+end

data/spec/omniauth/strategy_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+class ExampleStrategy
+  include OmniAuth::Strategy
+  def call(env); self.call!(env) end
+  attr_reader :last_env
+  def request_phase
+    @fail = fail!(options[:failure]) if options[:failure]
+    @last_env = env    
+    return @fail if @fail    
+    raise "Request Phase"
+  end
+  def callback_phase
+    @fail = fail!(options[:failure]) if options[:failure]
+    @last_env = env
+    return @fail if @fail    
+    raise "Callback Phase"
+  end
+end
+
+def make_env(path = '/auth/test', props = {})
+  {
+    'REQUEST_METHOD' => 'GET',
+    'PATH_INFO' => path,
+    'rack.session' => {},
+    'rack.input' => StringIO.new('test=true')
+  }.merge(props)
+end
+
+describe OmniAuth::Strategy do
+  let(:app){ lambda{|env| [404, {}, ['Awesome']]}}
+  describe '#initialize' do
+    context 'options extraction' do
+      it 'should be the last argument if the last argument is a Hash' do
+        ExampleStrategy.new(app, 'test', :abc => 123).options[:abc].should == 123
+      end
+    
+      it 'should be a blank hash if none are provided' do
+        ExampleStrategy.new(app, 'test').options.should == {}
+      end
+    end
+  end
+
+  describe '#full_host' do
+    let(:strategy){ ExampleStrategy.new(app, 'test', {}) }
+    it 'should not freak out if there is a pipe in the URL' do
+      strategy.call!(make_env('/whatever', 'rack.url_scheme' => 'http', 'SERVER_NAME' => 'facebook.lame', 'QUERY_STRING' => 'code=asofibasf|asoidnasd', 'SCRIPT_NAME' => '', 'SERVER_PORT' => 80))
+      lambda{ strategy.full_host }.should_not raise_error
+    end
+  end
+  
+  describe '#call' do
+    let(:strategy){ ExampleStrategy.new(app, 'test', @options) }
+    
+    context 'omniauth.origin' do
+      it 'should be set on the request phase' do
+        lambda{ strategy.call(make_env('/auth/test', 'HTTP_REFERER' => 'http://example.com/origin')) }.should raise_error("Request Phase")
+        strategy.last_env['rack.session']['omniauth.origin'].should == 'http://example.com/origin'
+      end
+
+      it 'should be turned into an env variable on the callback phase' do
+        lambda{ strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => 'http://example.com/origin'})) }.should raise_error("Callback Phase")
+        strategy.last_env['omniauth.origin'].should == 'http://example.com/origin'
+      end
+
+      it 'should set from the params if provided' do
+        lambda{ strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'origin=/foo')) }.should raise_error('Request Phase')
+        strategy.last_env['rack.session']['omniauth.origin'].should == '/foo'
+      end
+
+      it 'should be set on the failure env' do
+        OmniAuth.config.should_receive(:on_failure).and_return(lambda{|env| env})
+        @options = {:failure => :forced_fail}
+        strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => '/awesome'}))
+      end
+
+      context "with script_name" do
+        it 'should be set on the request phase, containing full path' do
+          env = {'HTTP_REFERER' => 'http://example.com/sub_uri/origin', 'SCRIPT_NAME' => '/sub_uri' }
+          lambda{ strategy.call(make_env('/auth/test', env)) }.should raise_error("Request Phase")
+          strategy.last_env['rack.session']['omniauth.origin'].should == 'http://example.com/sub_uri/origin'
+        end
+
+        it 'should be turned into an env variable on the callback phase, containing full path' do
+          env = {
+            'rack.session' => {'omniauth.origin' => 'http://example.com/sub_uri/origin'},
+            'SCRIPT_NAME' => '/sub_uri'
+          }
+
+          lambda{ strategy.call(make_env('/auth/test/callback', env)) }.should raise_error("Callback Phase")
+          strategy.last_env['omniauth.origin'].should == 'http://example.com/sub_uri/origin'
+        end
+
+      end
+    end
+
+    context 'default paths' do
+      it 'should use the default request path' do
+        lambda{ strategy.call(make_env) }.should raise_error("Request Phase")
+      end
+      
+      it 'should use the default callback path' do
+        lambda{ strategy.call(make_env('/auth/test/callback')) }.should raise_error("Callback Phase")
+      end
+
+      it 'should strip trailing spaces on request' do
+        lambda{ strategy.call(make_env('/auth/test/')) }.should raise_error("Request Phase")        
+      end
+
+      it 'should strip trailing spaces on callback' do
+        lambda{ strategy.call(make_env('/auth/test/callback/')) }.should raise_error("Callback Phase")
+      end
+
+      context 'callback_url' do
+        it 'uses the default callback_path' do
+          strategy.should_receive(:full_host).and_return('http://example.com')
+
+          lambda{ strategy.call(make_env) }.should raise_error("Request Phase")
+
+          strategy.callback_url.should == 'http://example.com/auth/test/callback'
+        end
+
+        it 'preserves the query parameters' do
+          strategy.stub(:full_host).and_return('http://example.com')
+          begin
+            strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'id=5'))
+          rescue RuntimeError; end
+          strategy.callback_url.should == 'http://example.com/auth/test/callback?id=5'
+        end
+
+        it 'consider script name' do
+          strategy.stub(:full_host).and_return('http://example.com')
+          begin
+            strategy.call(make_env('/auth/test', 'SCRIPT_NAME' => '/sub_uri'))
+          rescue RuntimeError; end
+          strategy.callback_url.should == 'http://example.com/sub_uri/auth/test/callback'
+        end
+      end
+    end
+    
+    context 'pre-request call through' do  
+      subject { ExampleStrategy.new(app, 'test') }
+      let(:app){ lambda{|env| env['omniauth.boom'] = true; [env['test.status'] || 404, {}, ['Whatev']] } }
+      it 'should be able to modify the env on the fly before the request_phase' do 
+        lambda{ subject.call(make_env) }.should raise_error("Request Phase")
+        subject.response.status.should == 404
+        subject.last_env.should be_key('omniauth.boom')
+      end
+
+      it 'should call through to the app instead if a non-404 response is received' do
+        lambda{ subject.call(make_env('/auth/test', 'test.status' => 200)) }.should_not raise_error
+        subject.response.body.should == ['Whatev']
+      end
+    end
+    
+    context 'custom paths' do
+      it 'should use a custom request_path if one is provided' do
+        @options = {:request_path => '/awesome'}
+        lambda{ strategy.call(make_env('/awesome')) }.should raise_error("Request Phase")
+      end
+    
+      it 'should use a custom callback_path if one is provided' do
+        @options = {:callback_path => '/radical'}
+        lambda{ strategy.call(make_env('/radical')) }.should raise_error("Callback Phase")
+      end
+
+      context 'callback_url' do
+        it 'uses a custom callback_path if one is provided' do
+          @options = {:callback_path => '/radical'}
+          strategy.should_receive(:full_host).and_return('http://example.com')
+
+          lambda{ strategy.call(make_env('/radical')) }.should raise_error("Callback Phase")
+
+          strategy.callback_url.should == 'http://example.com/radical'
+        end
+
+        it 'preserves the query parameters' do
+          @options = {:callback_path => '/radical'}
+          strategy.stub(:full_host).and_return('http://example.com')
+          begin
+            strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'id=5'))
+          rescue RuntimeError; end
+          strategy.callback_url.should == 'http://example.com/radical?id=5'
+        end
+      end
+    end
+    
+    context 'custom prefix' do
+      before do
+        @options = {:path_prefix => '/wowzers'}
+      end
+      
+      it 'should use a custom prefix for request' do
+        lambda{ strategy.call(make_env('/wowzers/test')) }.should raise_error("Request Phase")
+      end
+      
+      it 'should use a custom prefix for callback' do
+        lambda{ strategy.call(make_env('/wowzers/test/callback')) }.should raise_error("Callback Phase")
+      end
+
+      context 'callback_url' do
+        it 'uses a custom prefix' do
+          strategy.should_receive(:full_host).and_return('http://example.com')
+
+          lambda{ strategy.call(make_env('/wowzers/test')) }.should raise_error("Request Phase")
+
+          strategy.callback_url.should == 'http://example.com/wowzers/test/callback'
+        end
+
+        it 'preserves the query parameters' do
+          strategy.stub(:full_host).and_return('http://example.com')
+          begin
+            strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'id=5'))
+          rescue RuntimeError; end
+          strategy.callback_url.should == 'http://example.com/wowzers/test/callback?id=5'
+        end
+      end
+    end
+    
+    context 'request method restriction' do
+      before do
+        OmniAuth.config.allowed_request_methods = [:post]
+      end
+      
+      it 'should not allow a request method of the wrong type' do
+        lambda{ strategy.call(make_env)}.should_not raise_error
+      end
+      
+      it 'should allow a request method of the correct type' do
+        lambda{ strategy.call(make_env('/auth/test', 'REQUEST_METHOD' => 'POST'))}.should raise_error("Request Phase")
+      end
+      
+      after do
+        OmniAuth.config.allowed_request_methods = [:get, :post]        
+      end
+    end
+
+    context 'test mode' do
+      before do
+        OmniAuth.config.test_mode = true
+      end
+
+      it 'should short circuit the request phase entirely' do
+        response = strategy.call(make_env)
+        response[0].should == 302
+        response[1]['Location'].should == '/auth/test/callback'
+      end
+
+      it 'should not short circuit requests outside of authentication' do
+        strategy.call(make_env('/')).should == app.call(make_env('/'))
+      end
+
+      it 'should respond with the default hash if none is set' do
+        strategy.call make_env('/auth/test/callback')
+        strategy.env['omniauth.auth']['uid'].should == '1234'
+      end
+
+      it 'should respond with a provider-specific hash if one is set' do
+        OmniAuth.config.mock_auth[:test] = {
+          'uid' => 'abc'
+        }
+
+        strategy.call make_env('/auth/test/callback')
+        strategy.env['omniauth.auth']['uid'].should == 'abc'
+      end
+
+      it 'should simulate login failure if mocked data is set as a symbol' do
+        OmniAuth.config.mock_auth[:test] = :invalid_credentials
+
+        strategy.call make_env('/auth/test/callback')
+        strategy.env['omniauth.error.type'].should == :invalid_credentials
+      end
+      
+      it 'should set omniauth.origin on the request phase' do
+        strategy.call(make_env('/auth/test', 'HTTP_REFERER' => 'http://example.com/origin'))
+        strategy.env['rack.session']['omniauth.origin'].should == 'http://example.com/origin'
+      end
+      
+      it 'should set omniauth.origin from the params if provided' do
+        strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'origin=/foo'))
+        strategy.env['rack.session']['omniauth.origin'].should == '/foo'
+      end
+
+      it 'should turn omniauth.origin into an env variable on the callback phase' do
+        OmniAuth.config.mock_auth[:test] = {}
+        
+        strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => 'http://example.com/origin'}))
+        strategy.env['omniauth.origin'].should == 'http://example.com/origin'
+      end
+    end
+
+    context 'custom full_host' do
+      it 'should be the string when a string is there' do
+        OmniAuth.config.full_host = 'my.host.com'
+        strategy.full_host.should == 'my.host.com'
+      end
+
+      it 'should run the proc with the env when it is a proc' do
+        OmniAuth.config.full_host = Proc.new{|env| env['HOST']}
+        strategy.call(make_env('/auth/test', 'HOST' => 'my.host.net'))
+        strategy.full_host.should == 'my.host.net'
+      end
+    end
+  end
+
+  context 'setup phase' do
+    context 'when options[:setup] = true' do
+      let(:strategy){ ExampleStrategy.new(app, 'test', :setup => true) }      
+      let(:app){lambda{|env| env['omniauth.strategy'].options[:awesome] = 'sauce' if env['PATH_INFO'] == '/auth/test/setup'; [404, {}, 'Awesome'] }}
+
+      it 'should call through to /auth/:provider/setup' do
+        strategy.call(make_env('/auth/test'))
+        strategy.options[:awesome].should == 'sauce'
+      end
+
+      it 'should not call through on a non-omniauth endpoint' do
+        strategy.call(make_env('/somewhere/else'))
+        strategy.options[:awesome].should_not == 'sauce'
+      end
+    end
+
+    context 'when options[:setup] is an app' do
+      let(:setup_proc) do
+        Proc.new do |env|
+          env['omniauth.strategy'].options[:awesome] = 'sauce'
+        end
+      end
+
+      let(:strategy){ ExampleStrategy.new(app, 'test', :setup => setup_proc) }
+      
+      it 'should not call the app on a non-omniauth endpoint' do
+        strategy.call(make_env('/somehwere/else'))
+        strategy.options[:awesome].should_not == 'sauce'
+      end
+
+      it 'should call the rack app' do
+        strategy.call(make_env('/auth/test'))
+        strategy.options[:awesome].should == 'sauce'  
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'simplecov'
+SimpleCov.start
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'rspec'
+require 'rspec/autorun'
+require 'rack/test'
+require 'omniauth/core'
+require 'omniauth/test'
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+  config.extend  OmniAuth::Test::StrategyMacros, :type => :strategy
+end
+

metadata

@@ -2,118 +2,76 @@
 name: oa-core
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Michael Bleigh
+- Erik Michaels-Ober
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-04-21 00:00:00 -05:00
-default_executable: 
+date: 2011-04-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rack
+  name: simplecov
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: "1.1"
-  type: :runtime
-  prerelease: false
+        version: "0.4"
+  type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: addressable
+  name: rack-test
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.2.4
+        version: "0.5"
   type: :development
-  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rake
+  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: "0.8"
   type: :development
-  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: mg
+  name: rspec
+  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.0.8
+        version: "2.5"
   type: :development
-  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: yard
+  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.3.0
+        version: "0.6"
   type: :development
-  prerelease: false
   version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: webmock
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 1.3.4
-  type: :development
-  prerelease: false
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: rack-test
-  requirement: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 0.5.4
-  type: :development
-  prerelease: false
-  version_requirements: *id007
-- !ruby/object:Gem::Dependency 
-  name: json_pure
-  requirement: &id008 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 1.5.1
-  type: :development
-  prerelease: false
-  version_requirements: *id008
-- !ruby/object:Gem::Dependency 
-  name: evernote
-  requirement: &id009 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 0.9.0
-  type: :development
-  prerelease: false
-  version_requirements: *id009
 description: HTTP Basic strategies for OmniAuth.
-email: michael@intridea.com
+email: 
+- michael@intridea.com
+- sferik@gmail.com
 executables: []
 
 extensions: []
@@ -121,17 +79,27 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .gemtest
+- .rspec
+- .yardopts
+- Gemfile
+- LICENSE
+- Rakefile
+- autotest/discover.rb
 - lib/oa-core.rb
 - lib/omniauth/builder.rb
 - lib/omniauth/core.rb
 - lib/omniauth/form.rb
 - lib/omniauth/strategy.rb
+- lib/omniauth/test.rb
 - lib/omniauth/test/phony_session.rb
 - lib/omniauth/test/strategy_macros.rb
 - lib/omniauth/test/strategy_test_case.rb
-- lib/omniauth/test.rb
-- LICENSE
-has_rdoc: true
+- oa-core.gemspec
+- spec/omniauth/builder_spec.rb
+- spec/omniauth/core_spec.rb
+- spec/omniauth/strategy_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/intridea/omniauth
 licenses: []
 
@@ -145,25 +113,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -927644400765707217
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -927644400765707217
-      segments: 
-      - 0
-      version: "0"
+      version: 1.3.6
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: HTTP Basic strategies for OmniAuth.
-test_files: []
-
+test_files: 
+- spec/omniauth/builder_spec.rb
+- spec/omniauth/core_spec.rb
+- spec/omniauth/strategy_spec.rb
+- spec/spec_helper.rb
+has_rdoc: