omniauth-1.1.4/0000755000175000017500000000000012132745645012676 5ustar ondrejondrejomniauth-1.1.4/LICENSE.md0000644000175000017500000000207212132745645014303 0ustar ondrejondrejCopyright (c) 2010-2013 Michael Bleigh and Intridea, Inc. 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. omniauth-1.1.4/spec/0000755000175000017500000000000012132745645013630 5ustar ondrejondrejomniauth-1.1.4/spec/omniauth_spec.rb0000644000175000017500000000620512132745645017016 0ustar ondrejondrejrequire 'helper' describe OmniAuth do describe ".strategies" do it "increases when a new strategy is made" do expect{ class ExampleStrategy include OmniAuth::Strategy end }.to change(OmniAuth.strategies, :size).by(1) expect(OmniAuth.strategies.last).to eq(ExampleStrategy) end end context "configuration" do describe ".defaults" do it "is a hash of default configuration" do expect(OmniAuth::Configuration.defaults).to be_kind_of(Hash) end end it "is callable from .configure" do OmniAuth.configure do |c| expect(c).to 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 "is able to set the path" do OmniAuth.configure do |config| config.path_prefix = '/awesome' end expect(OmniAuth.config.path_prefix).to eq('/awesome') end it "is able to set the on_failure rack app" do OmniAuth.configure do |config| config.on_failure do 'yoyo' end end expect(OmniAuth.config.on_failure.call).to eq('yoyo') end describe "mock auth" do before do OmniAuth.config.add_mock(:facebook, :uid => '12345',:info=>{:name=>'Joe', :email=>'joe@example.com'}) end it "default should be AuthHash" do OmniAuth.configure do |config| expect(config.mock_auth[:default]).to be_kind_of(OmniAuth::AuthHash) end end it "facebook should be AuthHash" do OmniAuth.configure do |config| expect(config.mock_auth[:facebook]).to be_kind_of(OmniAuth::AuthHash) end end it "sets facebook attributes" do OmniAuth.configure do |config| expect(config.mock_auth[:facebook].uid).to eq('12345') expect(config.mock_auth[:facebook].info.name).to eq('Joe') expect(config.mock_auth[:facebook].info.email).to eq('joe@example.com') end end end end describe ".logger" do it "calls through to the configured logger" do OmniAuth.stub(:config => mock(:logger => "foo")) expect(OmniAuth.logger).to eq("foo") end end describe "::Utils" do describe ".deep_merge" do it "combines hashes" do expect(OmniAuth::Utils.deep_merge({'abc' => {'def' => 123}}, {'abc' => {'foo' => 'bar'}})).to eq({'abc' => {'def' => 123, 'foo' => 'bar'}}) end end describe ".camelize" do it "works on normal cases" do { 'some_word' => 'SomeWord', 'AnotherWord' => 'AnotherWord', 'one' => 'One', 'three_words_now' => 'ThreeWordsNow' }.each_pair{ |k,v| expect(OmniAuth::Utils.camelize(k)).to eq(v) } end it "works in special cases that have been added" do OmniAuth.config.add_camelization('oauth', 'OAuth') expect(OmniAuth::Utils.camelize(:oauth)).to eq('OAuth') end end end end omniauth-1.1.4/spec/helper.rb0000644000175000017500000000202212132745645015430 0ustar ondrejondrejrequire 'simplecov' require 'coveralls' SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[ SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter ] SimpleCov.start require 'rspec' require 'rack/test' require 'omniauth' require 'omniauth/test' OmniAuth.config.logger = Logger.new("/dev/null") RSpec.configure do |config| config.include Rack::Test::Methods config.extend OmniAuth::Test::StrategyMacros, :type => :strategy config.expect_with :rspec do |c| c.syntax = :expect end end class ExampleStrategy include OmniAuth::Strategy option :name, 'test' def call(env); self.call!(env) end attr_reader :last_env def initialize(*args, &block) super @fail = nil end 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 omniauth-1.1.4/spec/omniauth/0000755000175000017500000000000012132745645015454 5ustar ondrejondrejomniauth-1.1.4/spec/omniauth/failure_endpoint_spec.rb0000644000175000017500000000311612132745645022343 0ustar ondrejondrejrequire 'helper' describe OmniAuth::FailureEndpoint do subject{ OmniAuth::FailureEndpoint } context "development" do before do @rack_env = ENV['RACK_ENV'] ENV['RACK_ENV'] = 'development' end it "raises out the error" do expect do subject.call('omniauth.error' => StandardError.new("Blah")) end.to raise_error(StandardError, "Blah") end it "raises out an OmniAuth::Error if no omniauth.error is set" do expect{ subject.call('omniauth.error.type' => 'example') }.to raise_error(OmniAuth::Error, "example") end after do ENV['RACK_ENV'] = @rack_env end end context "non-development" do let(:env){ {'omniauth.error.type' => 'invalid_request', 'omniauth.error.strategy' => ExampleStrategy.new({}) } } it "is a redirect" do status, _, _ = *subject.call(env) expect(status).to eq(302) end it "includes the SCRIPT_NAME" do _, head, _ = *subject.call(env.merge('SCRIPT_NAME' => '/random')) expect(head['Location']).to eq('/random/auth/failure?message=invalid_request&strategy=test') end it "respects the configured path prefix" do OmniAuth.config.stub(:path_prefix => '/boo') _, head, _ = *subject.call(env) expect(head["Location"]).to eq('/boo/failure?message=invalid_request&strategy=test') end it "includes the origin (escaped) if one is provided" do env.merge! 'omniauth.origin' => '/origin-example' _, head, _ = *subject.call(env) expect(head['Location']).to be_include('&origin=%2Forigin-example') end end end omniauth-1.1.4/spec/omniauth/strategies/0000755000175000017500000000000012132745645017626 5ustar ondrejondrejomniauth-1.1.4/spec/omniauth/strategies/developer_spec.rb0000644000175000017500000000404612132745645023156 0ustar ondrejondrejrequire 'helper' describe OmniAuth::Strategies::Developer do let(:app){ Rack::Builder.new do |b| b.use Rack::Session::Cookie, {:secret => "abc123"} b.use OmniAuth::Strategies::Developer b.run lambda{|env| [200, {}, ['Not Found']]} end.to_app } context "request phase" do before(:each){ get '/auth/developer' } it "displays a form" do expect(last_response.status).to eq(200) expect(last_response.body).to be_include(" 'Example User', :email => 'user@example.com' end it "sets the name in the auth hash" do expect(auth_hash.info.name).to eq('Example User') end it "sets the email in the auth hash" do expect(auth_hash.info.email).to eq('user@example.com') end it "sets the uid to the email" do expect(auth_hash.uid).to eq('user@example.com') end end context "with custom options" do let(:app){ Rack::Builder.new do |b| b.use Rack::Session::Cookie, {:secret => "abc123"} b.use OmniAuth::Strategies::Developer, :fields => [:first_name, :last_name], :uid_field => :last_name b.run lambda{|env| [200, {}, ['Not Found']]} end.to_app } before do @options = {:uid_field => :last_name, :fields => [:first_name, :last_name]} post '/auth/developer/callback', :first_name => 'Example', :last_name => 'User' end it "sets info fields properly" do expect(auth_hash.info.name).to eq('Example User') end it "sets the uid properly" do expect(auth_hash.uid).to eq('User') end end end end omniauth-1.1.4/spec/omniauth/strategy_spec.rb0000644000175000017500000005724512132745645020672 0ustar ondrejondrejrequire 'helper' 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']]}} let(:fresh_strategy){ c = Class.new; c.send :include, OmniAuth::Strategy; c} describe ".default_options" do it "is inherited from a parent class" do superklass = Class.new superklass.send :include, OmniAuth::Strategy superklass.configure do |c| c.foo = 'bar' end klass = Class.new(superklass) expect(klass.default_options.foo).to eq('bar') end end describe ".configure" do subject { klass = Class.new; klass.send :include, OmniAuth::Strategy; klass } context "when block is passed" do it "allows for default options setting" do subject.configure do |c| c.wakka = 'doo' end expect(subject.default_options["wakka"]).to eq("doo") end it "works when block doesn't evaluate to true" do environment_variable = nil subject.configure do |c| c.abc = '123' c.hgi = environment_variable end expect(subject.default_options["abc"]).to eq("123") end end it "takes a hash and deep merge it" do subject.configure :abc => {:def => 123} subject.configure :abc => {:hgi => 456} expect(subject.default_options['abc']).to eq({'def' => 123, 'hgi' => 456}) end end describe "#skip_info?" do it "is true if options.skip_info is true" do expect(ExampleStrategy.new(app, :skip_info => true)).to be_skip_info end it "is false if options.skip_info is false" do expect(ExampleStrategy.new(app, :skip_info => false)).not_to be_skip_info end it "is false by default" do expect(ExampleStrategy.new(app)).not_to be_skip_info end it "is true if options.skip_info is a callable that evaluates to truthy" do instance = ExampleStrategy.new(app, :skip_info => lambda{|uid| uid}) instance.should_receive(:uid).and_return(true) expect(instance).to be_skip_info end end describe ".option" do subject { klass = Class.new; klass.send :include, OmniAuth::Strategy; klass } it "sets a default value" do subject.option :abc, 123 expect(subject.default_options.abc).to eq(123) end it "sets the default value to nil if none is provided" do subject.option :abc expect(subject.default_options.abc).to be_nil end end describe ".args" do subject{ c = Class.new; c.send :include, OmniAuth::Strategy; c } it "sets args to the specified argument if there is one" do subject.args [:abc, :def] expect(subject.args).to eq([:abc, :def]) end it "is inheritable" do subject.args [:abc, :def] c = Class.new(subject) expect(c.args).to eq([:abc, :def]) end end context "fetcher procs" do subject{ fresh_strategy } %w(uid info credentials extra).each do |fetcher| describe ".#{fetcher}" do it "sets and retrieve a proc" do proc = lambda{ "Hello" } subject.send(fetcher, &proc) expect(subject.send(fetcher)).to eq(proc) end end end end context "fetcher stacks" do subject{ fresh_strategy } %w(uid info credentials extra).each do |fetcher| describe ".#{fetcher}_stack" do it "is an array of called ancestral procs" do fetchy = Proc.new{ "Hello" } subject.send(fetcher, &fetchy) expect(subject.send("#{fetcher}_stack", subject.new(app))).to eq(["Hello"]) end end end end %w(request_phase).each do |abstract_method| context "#{abstract_method}" do it "raises a NotImplementedError" do strat = Class.new strat.send :include, OmniAuth::Strategy expect{strat.new(app).send(abstract_method) }.to raise_error(NotImplementedError) end end end describe "#auth_hash" do subject do klass = Class.new klass.send :include, OmniAuth::Strategy klass.option :name, 'auth_hasher' klass end let(:instance){ subject.new(app) } it "calls through to uid and info" do instance.should_receive :uid instance.should_receive :info instance.auth_hash end it "returns an AuthHash" do instance.stub!(:uid).and_return('123') instance.stub!(:info).and_return(:name => 'Hal Awesome') hash = instance.auth_hash expect(hash).to be_kind_of(OmniAuth::AuthHash) expect(hash.uid).to eq('123') expect(hash.info.name).to eq('Hal Awesome') end end describe "#initialize" do context "options extraction" do it "is the last argument if the last argument is a Hash" do expect(ExampleStrategy.new(app, :abc => 123).options[:abc]).to eq(123) end it "is the default options if any are provided" do ExampleStrategy.stub!(:default_options).and_return(OmniAuth::Strategy::Options.new(:abc => 123)) expect(ExampleStrategy.new(app).options.abc).to eq(123) end end context "custom args" do subject{ c = Class.new; c.send :include, OmniAuth::Strategy; c } it "sets options based on the arguments if they are supplied" do subject.args [:abc, :def] s = subject.new app, 123, 456 expect(s.options[:abc]).to eq(123) expect(s.options[:def]).to eq(456) end end end describe "#call" do it "duplicates and calls" do klass = Class.new klass.send :include, OmniAuth::Strategy instance = klass.new(app) instance.should_receive(:dup).and_return(instance) instance.call({'rack.session' => {}}) end end describe "#inspect" do it "returns the class name" do expect(ExampleStrategy.new(app).inspect).to eq('#') end end describe "#redirect" do it "uses javascript if :iframe is true" do response = ExampleStrategy.new(app, :iframe => true).redirect("http://abc.com") expect(response.last.body.first).to be_include("top.location.href") end end describe "#callback_phase" do subject{ k = Class.new; k.send :include, OmniAuth::Strategy; k.new(app) } it "sets the auth hash" do env = make_env subject.stub!(:env).and_return(env) subject.stub!(:auth_hash).and_return("AUTH HASH") subject.callback_phase expect(env['omniauth.auth']).to eq("AUTH HASH") end end describe "#full_host" do let(:strategy){ ExampleStrategy.new(app, {}) } it "remains calm when 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)) expect{strategy.full_host }.not_to raise_error end end describe "#uid" do subject{ fresh_strategy } it "is the current class's uid if one exists" do subject.uid{ "Hi" } expect(subject.new(app).uid).to eq("Hi") end it "inherits if it can" do subject.uid{ "Hi" } c = Class.new(subject) expect(c.new(app).uid).to eq("Hi") end end %w(info credentials extra).each do |fetcher| subject{ fresh_strategy } it "is the current class's proc call if one exists" do subject.send(fetcher){ {:abc => 123} } expect(subject.new(app).send(fetcher)).to eq({:abc => 123}) end it "inherits by merging with preference for the latest class" do subject.send(fetcher){ {:abc => 123, :def => 456} } c = Class.new(subject) c.send(fetcher){ {:abc => 789} } expect(c.new(app).send(fetcher)).to eq({:abc => 789, :def => 456}) end end describe "#call" do before(:all) do @options = nil end let(:strategy){ ExampleStrategy.new(app, @options || {}) } context "omniauth.origin" do it "is set on the request phase" do expect{strategy.call(make_env('/auth/test', 'HTTP_REFERER' => 'http://example.com/origin')) }.to raise_error("Request Phase") expect(strategy.last_env['rack.session']['omniauth.origin']).to eq('http://example.com/origin') end it "is turned into an env variable on the callback phase" do expect{strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.origin' => 'http://example.com/origin'})) }.to raise_error("Callback Phase") expect(strategy.last_env['omniauth.origin']).to eq('http://example.com/origin') end it "sets from the params if provided" do expect{strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'origin=/foo')) }.to raise_error('Request Phase') expect(strategy.last_env['rack.session']['omniauth.origin']).to eq('/foo') end it "is 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 "is set on the request phase, containing full path" do env = {'HTTP_REFERER' => 'http://example.com/sub_uri/origin', 'SCRIPT_NAME' => '/sub_uri' } expect{strategy.call(make_env('/auth/test', env)) }.to raise_error("Request Phase") expect(strategy.last_env['rack.session']['omniauth.origin']).to eq('http://example.com/sub_uri/origin') end it "is 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' } expect{strategy.call(make_env('/auth/test/callback', env)) }.to raise_error("Callback Phase") expect(strategy.last_env['omniauth.origin']).to eq('http://example.com/sub_uri/origin') end end end context "default paths" do it "uses the default request path" do expect{strategy.call(make_env) }.to raise_error("Request Phase") end it "is case insensitive on request path" do expect{strategy.call(make_env('/AUTH/Test'))}.to raise_error("Request Phase") end it "is case insensitive on callback path" do expect{strategy.call(make_env('/AUTH/TeSt/CaLlBAck'))}.to raise_error("Callback Phase") end it "uses the default callback path" do expect{strategy.call(make_env('/auth/test/callback')) }.to raise_error("Callback Phase") end it "strips trailing spaces on request" do expect{strategy.call(make_env('/auth/test/')) }.to raise_error("Request Phase") end it "strips trailing spaces on callback" do expect{strategy.call(make_env('/auth/test/callback/')) }.to 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') expect{strategy.call(make_env) }.to raise_error("Request Phase") expect(strategy.callback_url).to eq('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 expect(strategy.callback_url).to eq('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 expect(strategy.callback_url).to eq('http://example.com/sub_uri/auth/test/callback') end end end context ":form option" do it "calls through to the supplied form option if one exists" do strategy.options.form = lambda{|env| "Called me!"} expect(strategy.call(make_env('/auth/test'))).to eq("Called me!") end it "calls through to the app if :form => true is set as an option" do strategy.options.form = true expect(strategy.call(make_env('/auth/test'))).to eq(app.call(make_env('/auth/test'))) end end context "dynamic paths" do it "runs the request phase if the custom request path evaluator is truthy" do @options = {:request_path => lambda{|env| true}} expect{strategy.call(make_env('/asoufibasfi')) }.to raise_error("Request Phase") end it "runs the callback phase if the custom callback path evaluator is truthy" do @options = {:callback_path => lambda{|env| true}} expect{strategy.call(make_env('/asoufiasod')) }.to raise_error("Callback Phase") end it "provides a custom callback path if request_path evals to a string" do strategy_instance = fresh_strategy.new(nil, :request_path => lambda{|env| "/auth/boo/callback/22" }) expect(strategy_instance.callback_path).to eq('/auth/boo/callback/22') end end context "custom paths" do it "uses a custom request_path if one is provided" do @options = {:request_path => '/awesome'} expect{strategy.call(make_env('/awesome')) }.to raise_error("Request Phase") end it "uses a custom callback_path if one is provided" do @options = {:callback_path => '/radical'} expect{strategy.call(make_env('/radical')) }.to 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') expect{strategy.call(make_env('/radical')) }.to raise_error("Callback Phase") expect(strategy.callback_url).to eq('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 expect(strategy.callback_url).to eq('http://example.com/radical?id=5') end end end context "custom prefix" do before do @options = {:path_prefix => '/wowzers'} end it "uses a custom prefix for request" do expect{strategy.call(make_env('/wowzers/test')) }.to raise_error("Request Phase") end it "uses a custom prefix for callback" do expect{strategy.call(make_env('/wowzers/test/callback')) }.to 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') expect{strategy.call(make_env('/wowzers/test')) }.to raise_error("Request Phase") expect(strategy.callback_url).to eq('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 expect(strategy.callback_url).to eq('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 "does not allow a request method of the wrong type" do expect{strategy.call(make_env)}.not_to raise_error end it "allows a request method of the correct type" do expect{strategy.call(make_env('/auth/test', 'REQUEST_METHOD' => 'POST'))}.to raise_error("Request Phase") end after do OmniAuth.config.allowed_request_methods = [:get, :post] end end context "receiving an OPTIONS request" do shared_examples_for "an OPTIONS request" do it "responds with 200" do expect(response[0]).to eq(200) end it "sets the Allow header properly" do expect(response[1]['Allow']).to eq("GET, POST") end end context "to the request path" do let(:response) { strategy.call(make_env('/auth/test', 'REQUEST_METHOD' => 'OPTIONS')) } it_behaves_like "an OPTIONS request" end context "to the request path" do let(:response) { strategy.call(make_env('/auth/test/callback', 'REQUEST_METHOD' => 'OPTIONS')) } it_behaves_like "an OPTIONS request" end context "to some other path" do it "does not short-circuit the request" do env = make_env('/other', 'REQUEST_METHOD' => 'OPTIONS') expect(strategy.call(env)).to eq(app.call(env)) end end end context "test mode" do let(:app) do # In test mode, the underlying app shouldn't be called on request phase. lambda { |env| [404, {"Content-Type" => "text/html"}, []] } end before do OmniAuth.config.test_mode = true end it "short circuits the request phase entirely" do response = strategy.call(make_env) expect(response[0]).to eq(302) expect(response[1]['Location']).to eq('/auth/test/callback') end it "is case insensitive on request path" do expect(strategy.call(make_env('/AUTH/Test'))[0]).to eq(302) end it "respects SCRIPT_NAME (a.k.a. BaseURI)" do response = strategy.call(make_env('/auth/test', 'SCRIPT_NAME' => '/sub_uri')) expect(response[1]['Location']).to eq('/sub_uri/auth/test/callback') end it "redirects on failure" do response = OmniAuth.config.on_failure.call(make_env('/auth/test', 'omniauth.error.type' => 'error')) expect(response[0]).to eq(302) expect(response[1]['Location']).to eq('/auth/failure?message=error') end it "respects SCRIPT_NAME (a.k.a. BaseURI) on failure" do response = OmniAuth.config.on_failure.call(make_env('/auth/test', 'SCRIPT_NAME' => '/sub_uri', 'omniauth.error.type' => 'error')) expect(response[0]).to eq(302) expect(response[1]['Location']).to eq('/sub_uri/auth/failure?message=error') end it "is case insensitive on callback path" do expect(strategy.call(make_env('/AUTH/TeSt/CaLlBAck')).first).to eq(strategy.call(make_env('/auth/test/callback')).first) end it "maintains query string parameters" do response = strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'cheese=stilton')) expect(response[1]['Location']).to eq('/auth/test/callback?cheese=stilton') end it "does not short circuit requests outside of authentication" do expect(strategy.call(make_env('/'))).to eq(app.call(make_env('/'))) end it "responds with the default hash if none is set" do OmniAuth.config.mock_auth[:test] = nil strategy.call make_env('/auth/test/callback') expect(strategy.env['omniauth.auth']['uid']).to eq('1234') end it "responds with a provider-specific hash if one is set" do OmniAuth.config.mock_auth[:test] = { 'uid' => 'abc' } strategy.call make_env('/auth/test/callback') expect(strategy.env['omniauth.auth']['uid']).to eq('abc') end it "simulates 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') expect(strategy.env['omniauth.error.type']).to eq(:invalid_credentials) end it "sets omniauth.origin on the request phase" do strategy.call(make_env('/auth/test', 'HTTP_REFERER' => 'http://example.com/origin')) expect(strategy.env['rack.session']['omniauth.origin']).to eq('http://example.com/origin') end it "sets omniauth.origin from the params if provided" do strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'origin=/foo')) expect(strategy.env['rack.session']['omniauth.origin']).to eq('/foo') end it "turns 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'})) expect(strategy.env['omniauth.origin']).to eq('http://example.com/origin') end it "sets omniauth.params on the request phase" do OmniAuth.config.mock_auth[:test] = {} strategy.call(make_env('/auth/test', 'QUERY_STRING' => 'foo=bar')) expect(strategy.env['rack.session']['omniauth.params']).to eq({'foo' => 'bar'}) end it "turns omniauth.params into an env variable on the callback phase" do OmniAuth.config.mock_auth[:test] = {} strategy.call(make_env('/auth/test/callback', 'rack.session' => {'omniauth.params' => {'foo' => 'bar'}})) expect(strategy.env['omniauth.params']).to eq({'foo' => 'bar'}) end after do OmniAuth.config.test_mode = false end end context "custom full_host" do before do OmniAuth.config.test_mode = true end it "is the string when a string is there" do OmniAuth.config.full_host = 'my.host.com' expect(strategy.full_host).to eq('my.host.com') end it "runs 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')) expect(strategy.full_host).to eq('my.host.net') end it "is based on the request if it's not a string nor a proc" do OmniAuth.config.full_host = nil strategy.call(make_env('/whatever', 'rack.url_scheme' => 'http', 'SERVER_NAME' => 'my.host.net', 'SERVER_PORT' => 80)) expect(strategy.full_host).to eq('http://my.host.net') end it "should honor HTTP_X_FORWARDED_PROTO if present" do OmniAuth.config.full_host = nil strategy.call(make_env('/whatever', 'HTTP_X_FORWARDED_PROTO' => 'https','rack.url_scheme' => 'http', 'SERVER_NAME' => 'my.host.net', 'SERVER_PORT' => 443)) expect(strategy.full_host).to eq('https://my.host.net') end after do OmniAuth.config.test_mode = false end end end context "setup phase" do before do OmniAuth.config.test_mode = true end context "when options[:setup] = true" do let(:strategy){ ExampleStrategy.new(app, :setup => true) } let(:app){lambda{|env| env['omniauth.strategy'].options[:awesome] = 'sauce' if env['PATH_INFO'] == '/auth/test/setup'; [404, {}, 'Awesome'] }} it "calls through to /auth/:provider/setup" do strategy.call(make_env('/auth/test')) expect(strategy.options[:awesome]).to eq('sauce') end it "does not call through on a non-omniauth endpoint" do strategy.call(make_env('/somewhere/else')) expect(strategy.options[:awesome]).not_to eq('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, :setup => setup_proc) } it "does not call the app on a non-omniauth endpoint" do strategy.call(make_env('/somehwere/else')) expect(strategy.options[:awesome]).not_to eq('sauce') end it "calls the rack app" do strategy.call(make_env('/auth/test')) expect(strategy.options[:awesome]).to eq('sauce') end end after do OmniAuth.config.test_mode = false end end end omniauth-1.1.4/spec/omniauth/auth_hash_spec.rb0000644000175000017500000000634212132745645020764 0ustar ondrejondrejrequire 'helper' describe OmniAuth::AuthHash do subject{ OmniAuth::AuthHash.new } it "converts a supplied info key into an InfoHash object" do subject.info = {:first_name => 'Awesome'} expect(subject.info).to be_kind_of(OmniAuth::AuthHash::InfoHash) expect(subject.info.first_name).to eq('Awesome') end describe "#valid?" do subject{ OmniAuth::AuthHash.new(:uid => '123', :provider => 'example', :info => {:name => 'Steven'}) } it "is valid with the right parameters" do expect(subject).to be_valid end it "requires a uid" do subject.uid = nil expect(subject).not_to be_valid end it "requires a provider" do subject.provider = nil expect(subject).not_to be_valid end it "requires a name in the user info hash" do subject.info.name = nil expect(subject).not_to be_valid? end end describe "#name" do subject{ OmniAuth::AuthHash.new( :info => { :name => 'Phillip J. Fry', :first_name => 'Phillip', :last_name => 'Fry', :nickname => 'meatbag', :email => 'fry@planetexpress.com' })} it "defaults to the name key" do expect(subject.info.name).to eq('Phillip J. Fry') end it "falls back to go to first_name last_name concatenation" do subject.info.name = nil expect(subject.info.name).to eq('Phillip Fry') end it "displays only a first or last name if only that is available" do subject.info.name = nil subject.info.first_name = nil expect(subject.info.name).to eq('Fry') end it "displays the nickname if no name, first, or last is available" do subject.info.name = nil %w(first_name last_name).each{|k| subject.info[k] = nil} expect(subject.info.name).to eq('meatbag') end it "displays the email if no name, first, last, or nick is available" do subject.info.name = nil %w(first_name last_name nickname).each{|k| subject.info[k] = nil} expect(subject.info.name).to eq('fry@planetexpress.com') end end describe "#to_hash" do subject{ OmniAuth::AuthHash.new(:uid => '123', :provider => 'test', :name => 'Bob Example')} let(:hash){ subject.to_hash } it "is a plain old hash" do expect(hash.class).to eq(::Hash) end it "has string keys" do expect(hash.keys).to be_include('uid') end it "converts an info hash as well" do subject.info = {:first_name => 'Bob', :last_name => 'Example'} expect(subject.info.class).to eq(OmniAuth::AuthHash::InfoHash) expect(subject.to_hash['info'].class).to eq(::Hash) end it "supplies the calculated name in the converted hash" do subject.info = {:first_name => 'Bob', :last_name => 'Examplar'} expect(hash['info']['name']).to eq('Bob Examplar') end it "does not pollute the URL hash with 'name' etc" do subject.info = {'urls' => {'Homepage' => "http://homepage.com"}} expect(subject.to_hash['info']['urls']).to eq({'Homepage' => "http://homepage.com"}) end end describe OmniAuth::AuthHash::InfoHash do describe "#valid?" do it "is valid if there is a name" do expect(OmniAuth::AuthHash::InfoHash.new(:name => 'Awesome')).to be_valid end end end end omniauth-1.1.4/spec/omniauth/builder_spec.rb0000644000175000017500000000245012132745645020442 0ustar ondrejondrejrequire 'helper' describe OmniAuth::Builder do describe "#provider" do it "translates 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 "accepts a class" do class ::ExampleClass; end expect{ OmniAuth::Builder.new(nil) do provider ::ExampleClass end }.not_to raise_error end it "raises a helpful LoadError message if it can't find the class" do expect { OmniAuth::Builder.new(nil) do provider :lorax end }.to raise_error(LoadError, "Could not find matching strategy for :lorax. You may need to install an additional gem (such as omniauth-lorax).") end end describe "#options" do it "merges provided options in" do k = Class.new b = OmniAuth::Builder.new(nil) b.should_receive(:use).with(k, :foo => 'bar', :baz => 'tik') b.options :foo => 'bar' b.provider k, :baz => 'tik' end it "adds an argument if no options are provided" do k = Class.new b = OmniAuth::Builder.new(nil) b.should_receive(:use).with(k, :foo => 'bar') b.options :foo => 'bar' b.provider k end end end omniauth-1.1.4/spec/omniauth/form_spec.rb0000644000175000017500000000137012132745645017757 0ustar ondrejondrejrequire 'helper' describe OmniAuth::Form do describe ".build" do it "yields the instance when called with a block and argument" do OmniAuth::Form.build{|f| expect(f).to be_kind_of(OmniAuth::Form)} end it "evaluates in the instance when called with a block and no argument" do OmniAuth::Form.build{|f| expect(f.class).to eq(OmniAuth::Form)} end end describe "#initialize" do it "sets the form action to the passed :url option" do expect(OmniAuth::Form.new(:url => '/awesome').to_html).to be_include("action='/awesome'") end it "sets an H1 tag from the passed :title option" do expect(OmniAuth::Form.new(:title => 'Something Cool').to_html).to be_include('

Something Cool

') end end end omniauth-1.1.4/Rakefile0000644000175000017500000000023612132745645014344 0ustar ondrejondrejrequire 'bundler' Bundler::GemHelper.install_tasks require 'rspec/core/rake_task' RSpec::Core::RakeTask.new(:spec) task :default => :spec task :test => :spec omniauth-1.1.4/data.tar.gz.sig0000444000175000017500000000040012132745645015507 0ustar ondrejondrej;oc(}TQ b Yg`lDKSEBe`a!*3g 6#MAw%F?/vzuNՐ;[D+siMBڝ@>VE1f*4w?]yEeұIj,d}]jwAMfU ړ - yG^&p'!%0 (A &pSPpmN)E/ǠD=TRO |uz]j(omniauth-1.1.4/metadata.gz.sig0000444000175000017500000000040012132745645015571 0ustar ondrejondrej@6 &hƮGc6޳|`joQ܎'L5S'gvA??-nf~tWk*bN;6+S 4S"PEq ­u|mPGܬH;;M zNTXzٮKBG/, ;:8C BMm\ W0MiCCA T4½d&B"A)("M?NFj_ ^YK'_6romniauth-1.1.4/checksums.yaml.gz.sig0000444000175000017500000000040012132745645016737 0ustar ondrejondrejf7,:e +tjO6{\KK-eKAY ʟ%Rmuƒ E gu`jFj,,GAX2HJ7l;Z#.i!  |P)brk\KW {}, :path_prefix => '/auth', :on_failure => OmniAuth::FailureEndpoint, :form_css => Form::DEFAULT_CSS, :test_mode => false, :logger => default_logger, :allowed_request_methods => [:get, :post], :mock_auth => { :default => AuthHash.new( 'provider' => 'default', 'uid' => '1234', 'info' => { 'name' => 'Bob Example' } ) } } def self.defaults @@defaults end def initialize @@defaults.each_pair{|k,v| self.send("#{k}=",v)} end def on_failure(&block) if block_given? @on_failure = block else @on_failure end end def add_mock(provider, mock={}) # Stringify keys recursively one level. mock.keys.each do |key| mock[key.to_s] = mock.delete(key) end mock.each_pair do |key, val| if val.is_a? Hash val.keys.each do |subkey| val[subkey.to_s] = val.delete(subkey) end end end # Merge with the default mock and ensure provider is correct. mock = self.mock_auth[:default].dup.merge(mock) mock["provider"] = provider.to_s # Add it to the mocks. self.mock_auth[provider.to_sym] = mock end # This is a convenience method to be used by strategy authors # so that they can add special cases to the camelization utility # method that allows OmniAuth::Builder to work. # # @param name [String] The underscored name, e.g. `oauth` # @param camelized [String] The properly camelized name, e.g. 'OAuth' def add_camelization(name, camelized) self.camelizations[name.to_s] = camelized.to_s end attr_writer :on_failure attr_accessor :path_prefix, :allowed_request_methods, :form_css, :test_mode, :mock_auth, :full_host, :camelizations, :logger end def self.config Configuration.instance end def self.configure yield config end def self.logger config.logger end def self.mock_auth_for(provider) config.mock_auth[provider.to_sym] || config.mock_auth[:default] end module Utils module_function def form_css "" end def deep_merge(hash, other_hash) target = hash.dup other_hash.keys.each do |key| if other_hash[key].is_a? ::Hash and hash[key].is_a? ::Hash target[key] = deep_merge(target[key],other_hash[key]) next end target[key] = other_hash[key] end target end def camelize(word, first_letter_in_uppercase = true) return OmniAuth.config.camelizations[word.to_s] if OmniAuth.config.camelizations[word.to_s] if first_letter_in_uppercase word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase } else word.first + camelize(word)[1..-1] end end end end omniauth-1.1.4/lib/omniauth/0000755000175000017500000000000012132745645015270 5ustar ondrejondrejomniauth-1.1.4/lib/omniauth/failure_endpoint.rb0000644000175000017500000000245412132745645021151 0ustar ondrejondrejmodule OmniAuth # This simple Rack endpoint that serves as the default # 'failure' mechanism for OmniAuth. If a strategy fails for # any reason this endpoint will be invoked. The default behavior # is to redirect to `/auth/failure` except in the case of # a development `RACK_ENV`, in which case an exception will # be raised. class FailureEndpoint attr_reader :env def self.call(env) new(env).call end def initialize(env) @env = env end def call raise_out! if ENV['RACK_ENV'].to_s == 'development' redirect_to_failure end def raise_out! raise env['omniauth.error'] || OmniAuth::Error.new(env['omniauth.error.type']) end def redirect_to_failure message_key = env['omniauth.error.type'] new_path = "#{env['SCRIPT_NAME']}#{OmniAuth.config.path_prefix}/failure?message=#{message_key}#{origin_query_param}#{strategy_name_query_param}" Rack::Response.new(["302 Moved"], 302, 'Location' => new_path).finish end def strategy_name_query_param return "" unless env['omniauth.error.strategy'] "&strategy=#{env['omniauth.error.strategy'].name}" end def origin_query_param return "" unless env['omniauth.origin'] "&origin=#{Rack::Utils.escape(env['omniauth.origin'])}" end end end omniauth-1.1.4/lib/omniauth/strategies/0000755000175000017500000000000012132745645017442 5ustar ondrejondrejomniauth-1.1.4/lib/omniauth/strategies/developer.rb0000644000175000017500000000327012132745645021756 0ustar ondrejondrejrequire 'omniauth' module OmniAuth module Strategies # The Developer strategy is a very simple strategy that can be used as a # placeholder in your application until a different authentication strategy # is swapped in. It has zero security and should *never* be used in a # production setting. # # ## Usage # # To use the Developer strategy, all you need to do is put it in like any # other strategy: # # @example Basic Usage # # use OmniAuth::Builder do # provider :developer # end # # @example Custom Fields # # use OmniAuth::Builder do # provider :developer, # :fields => [:first_name, :last_name], # :uid_field => :last_name # end # # This will create a strategy that, when the user visits `/auth/developer` # they will be presented a form that prompts for (by default) their name # and email address. The auth hash will be populated with these fields and # the `uid` will simply be set to the provided email. class Developer include OmniAuth::Strategy option :fields, [:name, :email] option :uid_field, :email def request_phase form = OmniAuth::Form.new(:title => "User Info", :url => callback_path) options.fields.each do |field| form.text_field field.to_s.capitalize.gsub("_", " "), field.to_s end form.button "Sign In" form.to_response end uid do request.params[options.uid_field.to_s] end info do options.fields.inject({}) do |hash, field| hash[field] = request.params[field.to_s] hash end end end end end omniauth-1.1.4/lib/omniauth/test/0000755000175000017500000000000012132745645016247 5ustar ondrejondrejomniauth-1.1.4/lib/omniauth/test/strategy_macros.rb0000644000175000017500000000143712132745645022007 0ustar ondrejondrejmodule OmniAuth module Test module StrategyMacros def sets_an_auth_hash it "sets an auth hash" do expect(last_request.env['omniauth.auth']).to be_kind_of(Hash) end end def sets_provider_to(provider) it "sets the provider to #{provider}" do expect((last_request.env['omniauth.auth'] || {})['provider']).to eq provider end end def sets_uid_to(uid) it "sets the UID to #{uid}" do expect((last_request.env['omniauth.auth'] || {})['uid']).to eq uid end end def sets_user_info_to(user_info) it "sets the user_info to #{user_info}" do expect((last_request.env['omniauth.auth'] || {})['user_info']).to eq user_info end end end end end omniauth-1.1.4/lib/omniauth/test/phony_session.rb0000644000175000017500000000030612132745645021473 0ustar ondrejondrejclass OmniAuth::Test::PhonySession def initialize(app); @app = app end def call(env) @session ||= (env['rack.session'] || {}) env['rack.session'] = @session @app.call(env) end end omniauth-1.1.4/lib/omniauth/test/strategy_test_case.rb0000644000175000017500000000217012132745645022470 0ustar ondrejondrejrequire 'rack' require 'omniauth/test' module OmniAuth module Test # Support for testing OmniAuth strategies. # # @example Usage # class MyStrategyTest < Test::Unit::TestCase # include OmniAuth::Test::StrategyTestCase # def strategy # # return the parameters to a Rack::Builder map call: # [MyStrategy.new, :some, :configuration, :options => 'here'] # end # setup do # post '/auth/my_strategy/callback', :user => { 'name' => 'Dylan', 'id' => '445' } # end # end module StrategyTestCase def app strat = self.strategy resp = self.app_response Rack::Builder.new { use OmniAuth::Test::PhonySession use *strat run lambda {|env| [404, {'Content-Type' => 'text/plain'}, [resp || env.key?('omniauth.auth').to_s]] } }.to_app end def app_response nil end def session last_request.env['rack.session'] end def strategy raise NotImplementedError.new('Including specs must define #strategy') end end end end omniauth-1.1.4/lib/omniauth/auth_hash.rb0000644000175000017500000000236212132745645017564 0ustar ondrejondrejrequire 'hashie/mash' module OmniAuth # The AuthHash is a normalized schema returned by all OmniAuth # strategies. It maps as much user information as the provider # is able to provide into the InfoHash (stored as the `'info'` # key). class AuthHash < Hashie::Mash def self.subkey_class; Hashie::Mash end # Tells you if this is considered to be a valid # OmniAuth AuthHash. The requirements for that # are that it has a provider name, a uid, and a # valid info hash. See InfoHash#valid? for # more details there. def valid? uid? && provider? && info? && info.valid? end def regular_writer(key, value) if key.to_s == 'info' && !value.is_a?(InfoHash) value = InfoHash.new(value) end super end class InfoHash < Hashie::Mash def self.subkey_class; Hashie::Mash end def name return self[:name] if self[:name] return "#{first_name} #{last_name}".strip if first_name? || last_name? return nickname if nickname? return email if email? nil end def name?; !!name end def valid? name? end def to_hash hash = super hash['name'] ||= name hash end end end end omniauth-1.1.4/lib/omniauth/test.rb0000644000175000017500000000043212132745645016573 0ustar ondrejondrejmodule OmniAuth # Support for testing OmniAuth strategies. module Test autoload :PhonySession, 'omniauth/test/phony_session' autoload :StrategyMacros, 'omniauth/test/strategy_macros' autoload :StrategyTestCase, 'omniauth/test/strategy_test_case' end end omniauth-1.1.4/lib/omniauth/form.rb0000644000175000017500000001041012132745645016554 0ustar ondrejondrejrequire 'omniauth' module OmniAuth class Form DEFAULT_CSS = <<-CSS body { background: #ccc; font-family: "Lucida Grande", "Lucida Sans", Helvetica, Arial, sans-serif; } h1 { text-align: center; margin: 30px auto 0px; font-size: 18px; padding: 10px 10px 15px; background: #555; color: white; width: 320px; border: 10px solid #444; border-bottom: 0; -moz-border-radius-topleft: 10px; -moz-border-radius-topright: 10px; -webkit-border-top-left-radius: 10px; -webkit-border-top-right-radius: 10px; border-top-left-radius: 10px; border-top-right-radius: 10px; } h1, form { -moz-box-shadow: 2px 2px 7px rgba(0,0,0,0.3); -webkit-box-shadow: 2px 2px 7px rgba(0,0,0,0.3); } form { background: white; border: 10px solid #eee; border-top: 0; padding: 20px; margin: 0px auto 40px; width: 300px; -moz-border-radius-bottomleft: 10px; -moz-border-radius-bottomright: 10px; -webkit-border-bottom-left-radius: 10px; -webkit-border-bottom-right-radius: 10px; border-bottom-left-radius: 10px; border-bottom-right-radius: 10px; } label { display: block; font-weight: bold; margin-bottom: 5px; } input { font-size: 18px; padding: 4px 8px; display: block; margin-bottom: 10px; width: 280px; } input#identifier, input#openid_url { background: url(http://openid.net/login-bg.gif) no-repeat; background-position: 0 50%; padding-left: 18px; } button { font-size: 22px; padding: 4px 8px; display: block; margin: 20px auto 0; } fieldset { border: 1px solid #ccc; border-left: 0; border-right: 0; padding: 10px 0; } fieldset input { width: 260px; font-size: 16px; } CSS attr_accessor :options def initialize(options = {}) options[:title] ||= "Authentication Info Required" options[:header_info] ||= "" self.options = options @html = "" @with_custom_button = false @footer = nil header(options[:title],options[:header_info]) end def self.build(options = {},&block) form = OmniAuth::Form.new(options) if block.arity > 0 yield form else form.instance_eval(&block) end form end def label_field(text, target) @html << "\n" self end def input_field(type, name) @html << "\n" self end def text_field(label, name) label_field(label, name) input_field('text', name) self end def password_field(label, name) label_field(label, name) input_field('password', name) self end def button(text) @with_custom_button = true @html << "\n" end def html(html) @html << html end def fieldset(legend, options = {}, &block) @html << "\n\n #{legend}\n" self.instance_eval(&block) @html << "\n" self end def header(title,header_info) @html << <<-HTML #{title} #{css} #{header_info}

#{title}

HTML self end def footer return self if @footer @html << "\n" unless @with_custom_button @html << <<-HTML
HTML @footer = true self end def to_html footer @html end def to_response footer Rack::Response.new(@html, 200, {"content-type" => "text/html"}).finish end protected def css "\n" end end end omniauth-1.1.4/lib/omniauth/strategy.rb0000644000175000017500000003515212132745645017465 0ustar ondrejondrejrequire 'omniauth' require 'hashie/mash' module OmniAuth class NoSessionError < StandardError; end # The Strategy is the base unit of OmniAuth's ability to # wrangle multiple providers. Each strategy provided by # OmniAuth includes this mixin to gain the default functionality # necessary to be compatible with the OmniAuth library. module Strategy def self.included(base) OmniAuth.strategies << base base.extend ClassMethods base.class_eval do option :setup, false option :skip_info, false end end module ClassMethods # Returns an inherited set of default options set at the class-level # for each strategy. def default_options return @default_options if instance_variable_defined?(:@default_options) && @default_options existing = superclass.respond_to?(:default_options) ? superclass.default_options : {} @default_options = OmniAuth::Strategy::Options.new(existing) end # This allows for more declarative subclassing of strategies by allowing # default options to be set using a simple configure call. # # @param options [Hash] If supplied, these will be the default options (deep-merged into the superclass's default options). # @yield [Options] The options Mash that allows you to set your defaults as you'd like. # # @example Using a yield to configure the default options. # # class MyStrategy # include OmniAuth::Strategy # # configure do |c| # c.foo = 'bar' # end # end # # @example Using a hash to configure the default options. # # class MyStrategy # include OmniAuth::Strategy # configure foo: 'bar' # end def configure(options = nil) if block_given? yield default_options else default_options.deep_merge!(options) end end # Directly declare a default option for your class. This is a useful from # a documentation perspective as it provides a simple line-by-line analysis # of the kinds of options your strategy provides by default. # # @param name [Symbol] The key of the default option in your configuration hash. # @param value [Object] The value your object defaults to. Nil if not provided. # # @example # # class MyStrategy # include OmniAuth::Strategy # # option :foo, 'bar' # option # end def option(name, value = nil) default_options[name] = value end # Sets (and retrieves) option key names for initializer arguments to be # recorded as. This takes care of 90% of the use cases for overriding # the initializer in OmniAuth Strategies. def args(args = nil) if args @args = Array(args) return end existing = superclass.respond_to?(:args) ? superclass.args : [] return (instance_variable_defined?(:@args) && @args) || existing end %w(uid info extra credentials).each do |fetcher| class_eval <<-RUBY def #{fetcher}(&block) return @#{fetcher}_proc unless block_given? @#{fetcher}_proc = block end def #{fetcher}_stack(context) compile_stack(self.ancestors, :#{fetcher}, context) end RUBY end def compile_stack(ancestors, method, context) stack = ancestors.inject([]) do |a, ancestor| a << context.instance_eval(&ancestor.send(method)) if ancestor.respond_to?(method) && ancestor.send(method) a end stack.reverse! end end attr_reader :app, :env, :options, :response # Initializes the strategy by passing in the Rack endpoint, # the unique URL segment name for this strategy, and any # additional arguments. An `options` hash is automatically # created from the last argument if it is a hash. # # @param app [Rack application] The application on which this middleware is applied. # # @overload new(app, options = {}) # If nothing but a hash is supplied, initialized with the supplied options # overriding the strategy's default options via a deep merge. # @overload new(app, *args, options = {}) # If the strategy has supplied custom arguments that it accepts, they may # will be passed through and set to the appropriate values. # # @yield [Options] Yields options to block for further configuration. def initialize(app, *args, &block) @app = app @env = nil @options = self.class.default_options.dup options.deep_merge!(args.pop) if args.last.is_a?(Hash) options.name ||= self.class.to_s.split('::').last.downcase self.class.args.each do |arg| options[arg] = args.shift end # Make sure that all of the args have been dealt with, otherwise error out. raise ArgumentError, "Received wrong number of arguments. #{args.inspect}" unless args.empty? yield options if block_given? end def inspect "#<#{self.class.to_s}>" end # Direct access to the OmniAuth logger, automatically prefixed # with this strategy's name. # # @example # log :warn, "This is a warning." def log(level, message) OmniAuth.logger.send(level, "(#{name}) #{message}") end # Duplicates this instance and runs #call! on it. # @param [Hash] The Rack environment. def call(env) dup.call!(env) end # The logic for dispatching any additional actions that need # to be taken. For instance, calling the request phase if # the request path is recognized. # # @param env [Hash] The Rack environment. def call!(env) raise OmniAuth::NoSessionError.new("You must provide a session to use OmniAuth.") unless env['rack.session'] @env = env @env['omniauth.strategy'] = self if on_auth_path? return mock_call!(env) if OmniAuth.config.test_mode return options_call if on_auth_path? && options_request? return request_call if on_request_path? && OmniAuth.config.allowed_request_methods.include?(request.request_method.downcase.to_sym) return callback_call if on_callback_path? return other_phase if respond_to?(:other_phase) @app.call(env) end # Responds to an OPTIONS request. def options_call verbs = OmniAuth.config.allowed_request_methods.map(&:to_s).map(&:upcase).join(', ') return [ 200, { 'Allow' => verbs }, [] ] end # Performs the steps necessary to run the request phase of a strategy. def request_call setup_phase log :info, "Request phase initiated." #store query params from the request url, extracted in the callback_phase session['omniauth.params'] = request.params if options.form.respond_to?(:call) log :info, "Rendering form from supplied Rack endpoint." options.form.call(env) elsif options.form log :info, "Rendering form from underlying application." call_app! else if request.params['origin'] env['rack.session']['omniauth.origin'] = request.params['origin'] elsif env['HTTP_REFERER'] && !env['HTTP_REFERER'].match(/#{request_path}$/) env['rack.session']['omniauth.origin'] = env['HTTP_REFERER'] end request_phase end end # Performs the steps necessary to run the callback phase of a strategy. def callback_call setup_phase log :info, "Callback phase initiated." @env['omniauth.origin'] = session.delete('omniauth.origin') @env['omniauth.origin'] = nil if env['omniauth.origin'] == '' @env['omniauth.params'] = session.delete('omniauth.params') || {} callback_phase end # Returns true if the environment recognizes either the # request or callback path. def on_auth_path? on_request_path? || on_callback_path? end def on_request_path? if options.request_path.respond_to?(:call) options.request_path.call(env) else on_path?(request_path) end end def on_callback_path? if options.callback_path.respond_to?(:call) options.callback_path.call(env) else on_path?(callback_path) end end def on_path?(path) current_path.casecmp(path) == 0 end def options_request? request.request_method == 'OPTIONS' end # This is called in lieu of the normal request process # in the event that OmniAuth has been configured to be # in test mode. def mock_call!(env) return mock_request_call if on_request_path? return mock_callback_call if on_callback_path? call_app! end def mock_request_call setup_phase session['omniauth.params'] = request.params if request.params['origin'] @env['rack.session']['omniauth.origin'] = request.params['origin'] elsif env['HTTP_REFERER'] && !env['HTTP_REFERER'].match(/#{request_path}$/) @env['rack.session']['omniauth.origin'] = env['HTTP_REFERER'] end redirect(script_name + callback_path + query_string) end def mock_callback_call setup_phase mocked_auth = OmniAuth.mock_auth_for(name.to_s) if mocked_auth.is_a?(Symbol) fail!(mocked_auth) else @env['omniauth.auth'] = mocked_auth @env['omniauth.params'] = session.delete('omniauth.params') || {} @env['omniauth.origin'] = session.delete('omniauth.origin') @env['omniauth.origin'] = nil if env['omniauth.origin'] == '' call_app! end end # The setup phase looks for the `:setup` option to exist and, # if it is, will call either the Rack endpoint supplied to the # `:setup` option or it will call out to the setup path of the # underlying application. This will default to `/auth/:provider/setup`. def setup_phase if options[:setup].respond_to?(:call) log :info, "Setup endpoint detected, running now." options[:setup].call(env) elsif options.setup? log :info, "Calling through to underlying application for setup." setup_env = env.merge('PATH_INFO' => setup_path, 'REQUEST_METHOD' => 'GET') call_app!(setup_env) end end # @abstract This method is called when the user is on the request path. You should # perform any information gathering you need to be able to authenticate # the user in this phase. def request_phase raise NotImplementedError end def uid self.class.uid_stack(self).last end def info merge_stack(self.class.info_stack(self)) end def credentials merge_stack(self.class.credentials_stack(self)) end def extra merge_stack(self.class.extra_stack(self)) end def auth_hash hash = AuthHash.new(:provider => name, :uid => uid) hash.info = info unless skip_info? hash.credentials = credentials if credentials hash.extra = extra if extra hash end # Determines whether or not user info should be retrieved. This # allows some strategies to save a call to an external API service # for existing users. You can use it either by setting the `:skip_info` # to true or by setting `:skip_info` to a Proc that takes a uid and # evaluates to true when you would like to skip info. # # @example # # use MyStrategy, :skip_info => lambda{|uid| User.find_by_uid(uid)} def skip_info? if options.skip_info? if options.skip_info.respond_to?(:call) return options.skip_info.call(uid) else return true end end false end def callback_phase self.env['omniauth.auth'] = auth_hash call_app! end def path_prefix options[:path_prefix] || OmniAuth.config.path_prefix end def custom_path(kind) if options[kind].respond_to?(:call) result = options[kind].call(env) return nil unless result.is_a?(String) result else options[kind] end end def request_path options[:request_path].is_a?(String) ? options[:request_path] : "#{path_prefix}/#{name}" end def callback_path options[:callback_path].is_a?(String) ? options[:callback_path] : (custom_path(:request_path) || "#{path_prefix}/#{name}/callback") end def setup_path options[:setup_path] || "#{path_prefix}/#{name}/setup" end def current_path request.path_info.downcase.sub(/\/$/,'') end def query_string request.query_string.empty? ? "" : "?#{request.query_string}" end def call_app!(env = @env) @app.call(env) end def full_host case OmniAuth.config.full_host when String OmniAuth.config.full_host when Proc OmniAuth.config.full_host.call(env) else uri = URI.parse(request.url.gsub(/\?.*$/,'')) uri.path = '' #sometimes the url is actually showing http inside rails because the other layers (like nginx) have handled the ssl termination. uri.scheme = 'https' if ssl? uri.to_s end end def callback_url full_host + script_name + callback_path + query_string end def script_name @env['SCRIPT_NAME'] || '' end def session @env['rack.session'] end def request @request ||= Rack::Request.new(@env) end def name options.name end def redirect(uri) r = Rack::Response.new if options[:iframe] r.write("") else r.write("Redirecting to #{uri}...") r.redirect(uri) end r.finish end def user_info; {} end def fail!(message_key, exception = nil) self.env['omniauth.error'] = exception self.env['omniauth.error.type'] = message_key.to_sym self.env['omniauth.error.strategy'] = self if exception log :error, "Authentication failure! #{message_key}: #{exception.class.to_s}, #{exception.message}" else log :error, "Authentication failure! #{message_key} encountered." end OmniAuth.config.on_failure.call(self.env) end class Options < Hashie::Mash; end protected def merge_stack(stack) stack.inject({}){|c,h| c.merge!(h); c} end def ssl? request.env['HTTPS'] == 'on' || request.env['HTTP_X_FORWARDED_SSL'] == 'on' || request.env['HTTP_X_FORWARDED_SCHEME'] == 'https' || (request.env['HTTP_X_FORWARDED_PROTO'] && request.env['HTTP_X_FORWARDED_PROTO'].split(',')[0] == 'https') || request.env['rack.url_scheme'] == 'https' end end end omniauth-1.1.4/lib/omniauth/version.rb0000644000175000017500000000011312132745645017275 0ustar ondrejondrejmodule OmniAuth VERSION = "1.1.4" unless defined?(OmniAuth::VERSION) end omniauth-1.1.4/lib/omniauth/builder.rb0000644000175000017500000000223712132745645017247 0ustar ondrejondrejrequire 'omniauth' module OmniAuth class Builder < ::Rack::Builder def initialize(app, &block) @options = nil if rack14? super else @app = app super(&block) @ins << @app end end def rack14? Rack.release.split('.')[1].to_i >= 4 end def on_failure(&block) OmniAuth.config.on_failure = block end def configure(&block) OmniAuth.configure(&block) end def options(options = false) return @options || {} if options == false @options = options end def provider(klass, *args, &block) if klass.is_a?(Class) middleware = klass else begin middleware = OmniAuth::Strategies.const_get("#{OmniAuth::Utils.camelize(klass.to_s)}") rescue NameError raise LoadError, "Could not find matching strategy for #{klass.inspect}. You may need to install an additional gem (such as omniauth-#{klass})." end end args.last.is_a?(Hash) ? args.push(options.merge(args.pop)) : args.push(options) use middleware, *args, &block end def call(env) to_app.call(env) end end end omniauth-1.1.4/README.md0000644000175000017500000001561012132745645014160 0ustar ondrejondrej# OmniAuth: Standardized Multi-Provider Authentication [![Gem Version](https://badge.fury.io/rb/omniauth.png)][gem] [![CI Build Status](https://secure.travis-ci.org/intridea/omniauth.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/intridea/omniauth.png?travis)][gemnasium] [![Code Climate](https://codeclimate.com/github/intridea/omniauth.png)][codeclimate] [![Coverage Status](https://coveralls.io/repos/intridea/omniauth/badge.png?branch=master)][coveralls] [gem]: https://rubygems.org/gems/omniauth [travis]: http://travis-ci.org/intridea/omniauth [gemnasium]: https://gemnasium.com/intridea/omniauth [codeclimate]: https://codeclimate.com/github/intridea/omniauth [coveralls]: https://coveralls.io/r/intridea/omniauth **OmniAuth 1.0 has several breaking changes from version 0.x. You can set the dependency to `~> 0.3.2` if you do not wish to make the more difficult upgrade. See [the wiki](https://github.com/intridea/omniauth/wiki/Upgrading-to-1.0) for more information.** ## An Introduction OmniAuth is a library that standardizes multi-provider authentication for web applications. It was created to be powerful, flexible, and do as little as possible. Any developer can create **strategies** for OmniAuth that can authenticate users via disparate systems. OmniAuth strategies have been created for everything from Facebook to LDAP. In order to use OmniAuth in your applications, you will need to leverage one or more strategies. These strategies are generally released individually as RubyGems, and you can see a [community maintained list](https://github.com/intridea/omniauth/wiki/List-of-Strategies) on the wiki for this project. One strategy, called `Developer`, is included with OmniAuth and provides a completely insecure, non-production-usable strategy that directly prompts a user for authentication information and then passes it straight through. You can use it as a placeholder when you start development and easily swap in other strategies later. ## Getting Started Each OmniAuth strategy is a Rack Middleware. That means that you can use it the same way that you use any other Rack middleware. For example, to use the built-in Developer strategy in a Sinatra application I might do this: ```ruby require 'sinatra' require 'omniauth' class MyApplication < Sinatra::Base use Rack::Session::Cookie use OmniAuth::Strategies::Developer end ``` Because OmniAuth is built for *multi-provider* authentication, I may want to leave room to run multiple strategies. For this, the built-in `OmniAuth::Builder` class gives you an easy way to specify multiple strategies. Note that there is **no difference** between the following code and using each strategy individually as middleware. This is an example that you might put into a Rails initializer at `config/initializers/omniauth.rb`: ```ruby Rails.application.config.middleware.use OmniAuth::Builder do provider :developer unless Rails.env.production? provider :twitter, ENV['TWITTER_KEY'], ENV['TWITTER_SECRET'] end ``` You should look to the documentation for each provider you use for specific initialization requirements. ## Integrating OmniAuth Into Your Application OmniAuth is an extremely low-touch library. It is designed to be a black box that you can send your application's users into when you need authentication and then get information back. OmniAuth was intentionally built not to automatically associate with a User model or make assumptions about how many authentication methods you might want to use or what you might want to do with the data once a user has authenticated. This makes OmniAuth incredibly flexible. To use OmniAuth, you need only to redirect users to `/auth/:provider`, where `:provider` is the name of the strategy (for example, `developer` or `twitter`). From there, OmniAuth will take over and take the user through the necessary steps to authenticate them with the chosen strategy. Once the user has authenticated, what do you do next? OmniAuth simply sets a special hash called the Authentication Hash on the Rack environment of a request to `/auth/:provider/callback`. This hash contains as much information about the user as OmniAuth was able to glean from the utilized strategy. You should set up an endpoint in your application that matches to the callback URL and then performs whatever steps are necessary for your application. For example, in a Rails app I would add a line in my `routes.rb` file like this: ```ruby match '/auth/:provider/callback', to: 'sessions#create' ``` And I might then have a `SessionsController` with code that looks something like this: ```ruby class SessionsController < ApplicationController def create @user = User.find_or_create_from_auth_hash(auth_hash) self.current_user = @user redirect_to '/' end protected def auth_hash request.env['omniauth.auth'] end end ``` The `omniauth.auth` key in the environment hash gives me my Authentication Hash which will contain information about the just authenticated user including a unique id, the strategy they just used for authentication, and personal details such as name and email address as available. For an in-depth description of what the authentication hash might contain, see the [Auth Hash Schema wiki page](https://github.com/intridea/omniauth/wiki/Auth-Hash-Schema). Note that OmniAuth does not perform any actions beyond setting some environment information on the callback request. It is entirely up to you how you want to implement the particulars of your application's authentication flow. ## Logging OmniAuth supports a configurable logger. By default, OmniAuth will log to `STDOUT` but you can configure this using `OmniAuth.config.logger`: ```ruby # Rails application example OmniAuth.config.logger = Rails.logger ``` ## Resources The [OmniAuth Wiki](https://github.com/intridea/omniauth/wiki) has actively maintained in-depth documentation for OmniAuth. It should be your first stop if you are wondering about a more in-depth look at OmniAuth, how it works, and how to use it. ## Supported Ruby Versions OmniAuth is tested under 1.8.7, 1.9.2, 1.9.3, JRuby (1.8 mode), and Rubinius (1.8 and 1.9 modes). ## Versioning This library aims to adhere to [Semantic Versioning 2.0.0][semver]. Violations of this scheme should be reported as bugs. Specifically, if a minor or patch version is released that breaks backward compatibility, that version should be immediately yanked and/or a new version should be immediately released that restores compatibility. Breaking changes to the public API will only be introduced with new major versions. As a result of this policy, you can (and should) specify a dependency on this gem using the [Pessimistic Version Constraint][pvc] with two digits of precision. For example: spec.add_dependency 'omniauth', '~> 1.0' [semver]: http://semver.org/ [pvc]: http://docs.rubygems.org/read/chapter/16#page74 ## License Copyright (c) 2010-2013 Michael Bleigh and Intridea, Inc. See [LICENSE][] for details. [license]: LICENSE.md omniauth-1.1.4/metadata.yml0000644000175000017500000001045112132745645015202 0ustar ondrejondrej--- !ruby/object:Gem::Specification name: omniauth version: !ruby/object:Gem::Version version: 1.1.4 platform: ruby authors: - Michael Bleigh - Erik Michaels-Ober autorequire: bindir: bin cert_chain: - | -----BEGIN CERTIFICATE----- MIIDLjCCAhagAwIBAgIBADANBgkqhkiG9w0BAQUFADA9MQ8wDQYDVQQDDAZzZmVy aWsxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2NvbTAe Fw0xMzAyMDMxMDAyMjdaFw0xNDAyMDMxMDAyMjdaMD0xDzANBgNVBAMMBnNmZXJp azEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29tMIIB IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAl0x5dx8uKxi7TkrIuyBUTJVB v1o93nUB9j/y4M96gV2rYwAci1JPBseNd6Fybzjo3YGuHl7EQHuSHNaf1p2lxew/ y60JXIJBBgPcDK/KCP4NUHofm0jfoYD+H5uNJfHCNq7/ZsTxOtE3Ra92s0BCMTpm wBMMlWR5MtdEhIYuBO4XhnejYgH0L/7BL2lymntVnsr/agdQoojQCN1IQmsRJvrR duZRO3tZvoIo1pBc4JEehDuqCeyBgPLOqMoKtQlold1TQs1kWUBK7KWMFEhKC/Kg zyzKRHQo9yDYwOvYngoBLY+T/lwCT4dyssdhzRbfnxAhaKu4SAssIwaC01yVowID AQABozkwNzAJBgNVHRMEAjAAMB0GA1UdDgQWBBS0ruDfRak5ci1OpDNX/ZdDEkIs iTALBgNVHQ8EBAMCBLAwDQYJKoZIhvcNAQEFBQADggEBAHHSMs/MP0sOaLkEv4Jo zvkm3qn5A6t0vaHx774cmejyMU+5wySxRezspL7ULh9NeuK2OhU+Oe3TpqrAg5TK R8GQILnVu2FemGA6sAkPDlcPtgA6ieI19PZOF6HVLmc/ID/dP/NgZWWzEeqQKmcK 2+HM+SEEDhZkScYekw4ZOe164ZtZG816oAv5x0pGitSIkumUp7V8iEZ/6ehr7Y9e XOg4eeun5L/JjmjARoW2kNdvkRD3c2EeSLqWvQRsBlypHfhs6JJuLlyZPGhU3R/v Sf3lVKpBCWgRpGTvy45XVpB+59y33PJmEuQ1PTEOYvQyao9UKMAAaAN/7qWQtjl0 hlw= -----END CERTIFICATE----- date: 2013-04-08 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: hashie requirement: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '1.2' - - < - !ruby/object:Gem::Version version: '3' type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '1.2' - - < - !ruby/object:Gem::Version version: '3' - !ruby/object:Gem::Dependency name: rack requirement: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '0' type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '0' - !ruby/object:Gem::Dependency name: bundler requirement: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: '1.0' type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: '1.0' description: A generalized Rack framework for multiple-provider authentication. email: - michael@intridea.com - sferik@gmail.com executables: [] extensions: [] extra_rdoc_files: [] files: - .yardopts - LICENSE.md - README.md - Rakefile - omniauth.gemspec - lib/omniauth/auth_hash.rb - lib/omniauth/builder.rb - lib/omniauth/failure_endpoint.rb - lib/omniauth/form.rb - lib/omniauth/strategies/developer.rb - lib/omniauth/strategy.rb - lib/omniauth/test/phony_session.rb - lib/omniauth/test/strategy_macros.rb - lib/omniauth/test/strategy_test_case.rb - lib/omniauth/test.rb - lib/omniauth/version.rb - lib/omniauth.rb - spec/helper.rb - spec/omniauth/auth_hash_spec.rb - spec/omniauth/builder_spec.rb - spec/omniauth/failure_endpoint_spec.rb - spec/omniauth/form_spec.rb - spec/omniauth/strategies/developer_spec.rb - spec/omniauth/strategy_spec.rb - spec/omniauth_spec.rb homepage: http://github.com/intridea/omniauth licenses: - MIT metadata: {} post_install_message: rdoc_options: [] require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '0' required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: 1.3.6 requirements: [] rubyforge_project: rubygems_version: 2.0.0 signing_key: specification_version: 4 summary: A generalized Rack framework for multiple-provider authentication. test_files: - spec/helper.rb - spec/omniauth/auth_hash_spec.rb - spec/omniauth/builder_spec.rb - spec/omniauth/failure_endpoint_spec.rb - spec/omniauth/form_spec.rb - spec/omniauth/strategies/developer_spec.rb - spec/omniauth/strategy_spec.rb - spec/omniauth_spec.rb has_rdoc: omniauth-1.1.4/checksums.yaml.gz0000444000175000017500000000041412132745645016163 0ustar ondrejondrej.bQe)@ E}7МTg b_I}7/x>y/?~<vcvtO}~}r5&eY˒bXk`[VYeO7$xĝ,# f@"ˡ6&C/]YJ D(U{ 2l)=N4n3U6fTb97<.Ca Pk"BtpFaVc͆{I?H}?omniauth-1.1.4/omniauth.gemspec0000644000175000017500000000222312132745645016066 0ustar ondrejondrej# coding: utf-8 lib = File.expand_path('../lib', __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'omniauth/version' Gem::Specification.new do |spec| spec.add_dependency 'hashie', ['>= 1.2', '< 3'] spec.add_dependency 'rack' spec.add_development_dependency 'bundler', '~> 1.0' spec.authors = ['Michael Bleigh', 'Erik Michaels-Ober'] spec.cert_chain = %w(certs/sferik.pem) spec.description = %q{A generalized Rack framework for multiple-provider authentication.} spec.email = ['michael@intridea.com', 'sferik@gmail.com'] spec.files = %w(.yardopts LICENSE.md README.md Rakefile omniauth.gemspec) spec.files += Dir.glob("lib/**/*.rb") spec.files += Dir.glob("spec/**/*") spec.homepage = 'http://github.com/intridea/omniauth' spec.licenses = ['MIT'] spec.name = 'omniauth' spec.require_paths = ['lib'] spec.required_rubygems_version = '>= 1.3.6' spec.signing_key = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/ spec.summary = spec.description spec.test_files = Dir.glob("spec/**/*") spec.version = OmniAuth::VERSION end