omniauth-rightsignature 0.0.4 → 0.0.5

data/lib/omniauth/test.rb

@@ -1,8 +0,0 @@
-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/lib/omniauth/version.rb

@@ -1,3 +0,0 @@
-module OmniAuth
-  VERSION = '1.2.2'
-end

data/lib/omniauth.rb

@@ -1,170 +0,0 @@
-require 'rack'
-require 'singleton'
-require 'logger'
-
-module OmniAuth
-  class Error < StandardError; end
-
-  module Strategies
-    autoload :Developer, 'omniauth/strategies/developer'
-  end
-
-  autoload :Builder,  'omniauth/builder'
-  autoload :Strategy, 'omniauth/strategy'
-  autoload :Test,     'omniauth/test'
-  autoload :Form,     'omniauth/form'
-  autoload :AuthHash, 'omniauth/auth_hash'
-  autoload :FailureEndpoint, 'omniauth/failure_endpoint'
-
-  def self.strategies
-    @strategies ||= []
-  end
-
-  class Configuration
-    include Singleton
-
-    def self.default_logger
-      logger = Logger.new(STDOUT)
-      logger.progname = 'omniauth'
-      logger
-    end
-
-    def self.defaults
-      @defaults ||= {
-        :camelizations => {},
-        :path_prefix => '/auth',
-        :on_failure => OmniAuth::FailureEndpoint,
-        :failure_raise_out_environments => ['development'],
-        :before_request_phase   => nil,
-        :before_callback_phase  => nil,
-        :before_options_phase   => nil,
-        :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' => 'Example User'})},
-      }
-    end
-
-    def initialize
-      self.class.defaults.each_pair { |k, v| send("#{k}=", v) }
-    end
-
-    def on_failure(&block)
-      if block_given?
-        @on_failure = block
-      else
-        @on_failure
-      end
-    end
-
-    def before_callback_phase(&block)
-      if block_given?
-        @before_callback_phase = block
-      else
-        @before_callback_phase
-      end
-    end
-
-    def before_options_phase(&block)
-      if block_given?
-        @before_options_phase = block
-      else
-        @before_options_phase
-      end
-    end
-
-    def before_request_phase(&block)
-      if block_given?
-        @before_request_phase = block
-      else
-        @before_request_phase
-      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
-        else
-          next
-        end
-      end
-
-      # Merge with the default mock and ensure provider is correct.
-      mock = mock_auth[:default].dup.merge(mock)
-      mock['provider'] = provider.to_s
-
-      # Add it to the mocks.
-      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)
-      camelizations[name.to_s] = camelized.to_s
-    end
-
-    attr_writer :on_failure, :before_callback_phase, :before_options_phase, :before_request_phase
-    attr_accessor :failure_raise_out_environments, :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
-      "<style type='text/css'>#{OmniAuth.config.form_css}</style>"
-    end
-
-    def deep_merge(hash, other_hash)
-      target = hash.dup
-
-      other_hash.keys.each do |key|
-        if other_hash[key].is_a?(::Hash) && 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(/\/(.?)/) { '::' + Regexp.last_match[1].upcase }.gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
-      else
-        word.first + camelize(word)[1..-1]
-      end
-    end
-  end
-end

data/spec/helper.rb

@@ -1,55 +0,0 @@
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-
-  SimpleCov.start do
-    add_filter '/spec'
-    minimum_coverage(93.05)
-  end
-end
-
-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
-  attr_reader :last_env
-  option :name, 'test'
-
-  def call(env)
-    self.call!(env)
-  end
-
-  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
-    fail('Request Phase')
-  end
-
-  def callback_phase
-    @fail = fail!(options[:failure]) if options[:failure]
-    @last_env = env
-    return @fail if @fail
-    fail('Callback Phase')
-  end
-end

data/spec/omniauth/auth_hash_spec.rb

@@ -1,109 +0,0 @@
-require '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 do
-      OmniAuth::AuthHash.new(:info => {
-                               :name => 'Phillip J. Fry',
-                               :first_name => 'Phillip',
-                               :last_name => 'Fry',
-                               :nickname => 'meatbag',
-                               :email => 'fry@planetexpress.com',
-                             })
-    end
-
-    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 => 'Example User') }
-    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 => 'Example', :last_name => 'User'}
-      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 => 'Examplar', :last_name => 'User'}
-      expect(hash['info']['name']).to eq('Examplar User')
-    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

data/spec/omniauth/builder_spec.rb

@@ -1,50 +0,0 @@
-require 'helper'
-
-describe OmniAuth::Builder do
-  describe '#provider' do
-    it 'translates a symbol to a constant' do
-      expect(OmniAuth::Strategies).to 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 do
-        OmniAuth::Builder.new(nil) do
-          provider ::ExampleClass
-        end
-      end.not_to raise_error
-    end
-
-    it "raises a helpful LoadError message if it can't find the class" do
-      expect do
-        OmniAuth::Builder.new(nil) do
-          provider :lorax
-        end
-      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)
-      expect(b).to 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)
-      expect(b).to receive(:use).with(k, :foo => 'bar')
-
-      b.options :foo => 'bar'
-      b.provider k
-    end
-  end
-end

data/spec/omniauth/failure_endpoint_spec.rb

@@ -1,58 +0,0 @@
-require 'helper'
-
-describe OmniAuth::FailureEndpoint do
-  subject { OmniAuth::FailureEndpoint }
-
-  context 'raise-out environment' do
-    before do
-      @rack_env = ENV['RACK_ENV']
-      ENV['RACK_ENV'] = 'test'
-
-      @default = OmniAuth.config.failure_raise_out_environments
-      OmniAuth.config.failure_raise_out_environments = ['test']
-    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
-      OmniAuth.config.failure_raise_out_environments = @default
-    end
-  end
-
-  context 'non-raise-out environment' do
-    let(:env) do
-      {'omniauth.error.type' => 'invalid_request', 'omniauth.error.strategy' => ExampleStrategy.new({})}
-    end
-
-    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
-      allow(OmniAuth.config).to receive(:path_prefix).and_return('/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