omniauth 0.2.4 → 0.2.5

data/oa-core/lib/omniauth/strategy.rb

@@ -0,0 +1,227 @@
+require 'omniauth/core'
+
+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.class_eval do
+        attr_reader :app, :name, :env, :options, :response
+      end
+    end
+
+    def initialize(app, name, *args, &block)
+      @app = app
+      @name = name.to_sym
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+
+      yield self if block_given?
+    end
+
+    def inspect
+      "#<#{self.class.to_s}>"
+    end
+
+    def call(env)
+      dup.call!(env)
+    end
+
+    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 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
+    
+    # Performs the steps necessary to run the request phase of a strategy.
+    def request_call
+      setup_phase
+      if response = call_through_to_app
+        response
+      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
+      @env['omniauth.origin'] = session.delete('omniauth.origin')
+      @env['omniauth.origin'] = nil if env['omniauth.origin'] == ''
+
+      callback_phase
+    end
+
+    def on_auth_path?
+      on_request_path? || on_callback_path?
+    end
+
+    def on_request_path?
+      current_path.casecmp(request_path) == 0
+    end
+
+    def on_callback_path?
+      current_path.casecmp(callback_path) == 0
+    end
+
+    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
+      return response if response = call_through_to_app
+
+      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(callback_path)
+    end
+
+    def mock_callback_call
+      setup_phase
+      mocked_auth = OmniAuth.mock_auth_for(name.to_sym)
+      if mocked_auth.is_a?(Symbol)
+        fail!(mocked_auth)
+      else
+        @env['omniauth.auth'] = mocked_auth
+        @env['omniauth.origin'] = session.delete('omniauth.origin')
+        @env['omniauth.origin'] = nil if env['omniauth.origin'] == ''
+        call_app!
+      end
+    end
+
+    def setup_phase
+      if options[:setup].respond_to?(:call)
+        options[:setup].call(env)
+      elsif options[:setup]
+        setup_env = env.merge('PATH_INFO' => setup_path, 'REQUEST_METHOD' => 'GET')
+        call_app!(setup_env)
+      end
+    end
+
+    def request_phase
+      raise NotImplementedError
+    end
+
+    def callback_phase
+      @env['omniauth.auth'] = auth_hash
+      call_app!
+    end
+
+    def path_prefix
+      options[:path_prefix] || OmniAuth.config.path_prefix
+    end
+
+    def request_path
+      options[:request_path] || "#{path_prefix}/#{name}"
+    end
+
+    def callback_path
+      options[:callback_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_through_to_app
+      status, headers, body = *call_app!
+      @response = Rack::Response.new(body, status, headers)
+
+      status == 404 ? nil : @response.finish
+    end
+
+    def call_app!(env = @env)
+      @app.call(env)
+    end
+
+    def auth_hash
+      {
+        'provider' => name.to_s,
+        'uid' => nil
+      }
+    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 = ''
+          uri.query = nil
+          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 redirect(uri)
+      r = Rack::Response.new
+
+      if options[:iframe]
+        r.write("<script type='text/javascript' charset='utf-8'>top.location.href = '#{uri}';</script>")
+      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
+
+      OmniAuth.config.on_failure.call(self.env)
+    end
+  end
+end

data/oa-core/lib/omniauth/test.rb

@@ -0,0 +1,12 @@
+module 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

data/oa-core/lib/omniauth/test/phony_session.rb

@@ -0,0 +1,8 @@
+class 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

data/oa-core/lib/omniauth/test/strategy_macros.rb

@@ -0,0 +1,34 @@
+module OmniAuth
+
+  module Test
+
+    module StrategyMacros
+
+      def sets_an_auth_hash
+        it 'should set an auth hash' do
+          last_request.env['omniauth.auth'].should be_kind_of(Hash)
+        end
+      end
+
+      def sets_provider_to(provider)
+        it "should set the provider to #{provider}" do
+          (last_request.env['omniauth.auth'] || {})['provider'].should == provider
+        end
+      end
+
+      def sets_uid_to(uid)
+        it "should set the UID to #{uid}" do
+          (last_request.env['omniauth.auth'] || {})['uid'].should == uid
+        end
+      end
+
+      def sets_user_info_to(user_info)
+        it "should set the user_info to #{user_info}" do
+          (last_request.env['omniauth.auth'] || {})['user_info'].should == user_info
+        end
+      end
+    end
+
+  end
+
+end

data/oa-core/lib/omniauth/test/strategy_test_case.rb

@@ -0,0 +1,49 @@
+require '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

data/oa-core/lib/omniauth/version.rb

@@ -0,0 +1,19 @@
+module OmniAuth
+  module Version
+    unless defined?(::OmniAuth::Version::MAJOR)
+      MAJOR = 0
+    end
+    unless defined?(::OmniAuth::Version::MINOR)
+      MINOR = 2
+    end
+    unless defined?(::OmniAuth::Version::PATCH)
+      PATCH = 5
+    end
+    unless defined?(::OmniAuth::Version::PRE)
+      PRE   = nil
+    end
+    unless defined?(::OmniAuth::Version::STRING)
+      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+  end
+end

data/oa-core/oa-core.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/omniauth/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.add_development_dependency 'maruku', '~> 0.6'
+  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.add_development_dependency 'ZenTest', '~> 4.5'
+  gem.name = 'oa-core'
+  gem.version = OmniAuth::Version::STRING
+  gem.description = %q{Core strategies for OmniAuth.}
+  gem.summary = gem.description
+  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/oa-core/spec/omniauth/builder_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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/oa-core/spec/omniauth/core_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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