omniauth-identity 1.1.1 → 3.0.3

data/Guardfile

@@ -1,10 +0,0 @@
-guard 'rspec', :version => 2 do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-end
-
-guard 'bundler' do
-  watch('Gemfile')
-  watch(/^.+\.gemspec/)
-end

data/README.markdown

@@ -1,202 +0,0 @@
-# OmniAuth Identity
-
-The OmniAuth Identity gem provides a way for applications to utilize a
-traditional login/password based authentication system without the need
-to give up the simple authentication flow provided by OmniAuth. Identity
-is designed on purpose to be as featureless as possible: it provides the
-basic construct for user management and then gets out of the way.
-
-## Usage
-
-This can be a bit hard to understand the first time. Luckily, Ryan Bates made
-a [Railscast](http://railscasts.com/episodes/304-omniauth-identity) about it!
-
-You use `omniauth-identity` just like you would any other OmniAuth provider: as a
-Rack middleware. The basic setup for a email/password authentication would
-look something like this:
-
-```ruby
-use OmniAuth::Builder do
-  provider :identity, :fields => [:email]
-end
-```
-
-Next, you need to create a model (called `Identity by default`) that will be
-able to persist the information provided by the user. Luckily for you, there
-are pre-built models for popular ORMs that make this dead simple.
-
-**Note:** OmniAuth Identity is different from many other user authentication
-systems in that it is *not* built to store authentication information in your primary
-`User` model. Instead, the `Identity` model should be **associated** with your
-`User` model giving you maximum flexibility to include other authentication
-strategies such as Facebook, Twitter, etc.
-
-### ActiveRecord
-
-Just subclass `OmniAuth::Identity::Models::ActiveRecord` and provide fields
-in the database for all of the fields you are using.
-
-```ruby
-class Identity < OmniAuth::Identity::Models::ActiveRecord
-  # Add whatever you like!
-end
-```
-
-### Mongoid
-
-Include the `OmniAuth::Identity::Models::Mongoid` mixin and specify
-fields that you will need.
-
-```ruby
-class Identity
-  include Mongoid::Document
-  include OmniAuth::Identity::Models::Mongoid
-
-  field :email, type: String
-  field :name, type: String
-  field :password_digest, type: String
-end
-```
-
-### MongoMapper
-
-Include the `OmniAuth::Identity::Models::MongoMapper` mixin and specify
-fields that you will need.
-
-```ruby
-class Identity
-  include MongoMapper::Document
-  include OmniAuth::Identity::Models::MongoMapper
-
-  key :email, String
-  key :name, String
-  key :password_digest, String
-end
-```
-
-### DataMapper
-
-Include the `OmniAuth::Identity::Models::DataMapper` mixin and specify
-fields that you will need.
-
-```ruby
-class Identity
-  include DataMapper::Resource
-  include OmniAuth::Identity::Models::DataMapper
-
-  property :id,              Serial
-  property :email,           String
-  property :password_digest, Text
-
-  attr_accessor :password_confirmation
-
-end
-```
-
-### CouchPotato
-
-Include the `OmniAuth::Identity::Models::CouchPotatoModule` mixin and specify fields that you will need.
-
-```ruby
-class Identity
-  include CouchPotato::Persistence
-  include OmniAuth::Identity::Models::CouchPotatoModule
-
-  property :email
-  property :password_digest
-
-  def self.where search_hash
-    CouchPotato.database.view Identity.by_email(:key => search_hash)
-  end
-
-  view :by_email, :key => :email
-end
-```
-
-Once you've got an Identity persistence model and the strategy up and
-running, you can point users to `/auth/identity` and it will request
-that they log in or give them the opportunity to sign up for an account.
-Once they have authenticated with their identity, OmniAuth will call
-through to `/auth/identity/callback` with the same kinds of information
-it would had the user authenticated through an external provider.
-Simple!
-
-## Custom Auth Model
-
-To use a class other than the default, specify the <tt>:model</tt> option to a
-different class.
-
-```ruby
-use OmniAuth::Builder do
-  provider :identity, :fields => [:email], :model => MyCustomClass
-end
-```
-
-## Customizing Registration Failure
-
-To use your own custom registration form, create a form that POSTs to
-'/auth/identity/register' with 'password', 'password_confirmation', and your
-other fields.
-
-```erb
-<%= form_tag '/auth/identity/register' do |f| %>
-  <h1>Create an Account</h1>
-  <%= text_field_tag :email %>
-  <%= password_field_tag :password %>
-  <%= password_field_tag :password_confirmation %>
-  <%= submit_tag %>
-<% end %>
-```
-
-Beware not to nest your form parameters within a namespace. This strategy
-looks for the form parameters at the top level of the post params. If you are
-using [simple\_form](https://github.com/plataformatec/simple_form), then you
-can avoid the params nesting by specifying <tt>:input_html</tt>.
-
-```erb
-<%= simple_form_for @identity, :url => '/auth/identity/register' do |f| %>
-  <h1>Create an Account</h1>
-  <%# specify :input_html to avoid params nesting %>
-  <%= f.input :email, :input_html => {:name => 'email'} %>
-  <%= f.input :password, :as => 'password', :input_html => {:name => 'password'} %>
-  <%= f.input :password_confirmation, :label => "Confirm Password", :as => 'password', :input_html => {:name => 'password_confirmation'} %>
-  <button type='submit'>Sign Up</button>
-<% end %>
-```
-
-Next you'll need to let OmniAuth know what action to call when a registration
-fails. In your OmniAuth configuration, specify any valid rack endpoint in the
-<tt>:on_failed_registration</tt> option.
-
-```ruby
-use OmniAuth::Builder do
-  provider :identity,
-    :fields => [:email],
-    :on_failed_registration => UsersController.action(:new)
-end
-```
-
-For more information on rack endpoints, check out [this
-introduction](http://library.edgecase.com/Rails/2011/01/04/rails-routing-and-rack-endpoints.html)
-and
-[ActionController::Metal](http://rubydoc.info/docs/rails/ActionController/Metal)
-
-## Customizing Locate Conditions
-
-You can customize the way that matching records are found when authenticating.
-For example, for a site with multiple domains, you may wish to scope the search
-within a particular subdomain.  To do so, add :locate_conditions to your config.
-The default value is:
-
-```ruby
-:locate_conditions => lambda { |req| { model.auth_key => req['auth_key']} }
-```
-
-locate_conditions takes a Proc object, and must return a hash.  The resulting hash is used
-as a parameter in the locate method for your ORM.  The proc is evaluated in the
-callback context, and has access to the Identity model (using `model`) and receives the request
-object as a parameter.  Note  that model.auth_key defaults to 'email', but is also configurable.
-
-Note: Be careful when customizing locate_conditions.  The best way to modify the conditions is
-to copy the default value, and then add to the hash.  Removing the default condition will almost
-always break things!

data/Rakefile

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

data/lib/omniauth/identity/models/data_mapper.rb

@@ -1,32 +0,0 @@
-require 'dm-core'
-require 'dm-validations'
-
-module OmniAuth
-  module Identity
-    module Models
-      module DataMapper
-        def self.included(base)
-          base.class_eval do
-            include OmniAuth::Identity::Model
-            include OmniAuth::Identity::SecurePassword
-
-            # http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-persisted-3F
-            # http://rubydoc.info/github/mongoid/mongoid/master/Mongoid/State#persisted%3F-instance_method
-            alias persisted? valid?
-
-            has_secure_password
-
-            def self.auth_key=(key)
-              super
-              validates_uniqueness_of :key
-            end
-
-            def self.locate(search_hash)
-              all(search_hash).first
-            end
-          end
-        end
-      end # DataMapper
-    end
-  end
-end

data/omniauth-identity.gemspec

@@ -1,32 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.dirname(__FILE__) + '/lib/omniauth-identity/version'
-
-Gem::Specification.new do |gem|
-  gem.add_runtime_dependency 'omniauth', '~> 1.0'
-  gem.add_runtime_dependency 'bcrypt-ruby', '~> 3.0'
-
-  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.7'
-  gem.add_development_dependency 'activerecord', '~> 3.1'
-  gem.add_development_dependency 'mongoid'
-  gem.add_development_dependency 'mongo_mapper'
-  gem.add_development_dependency 'datamapper'
-  gem.add_development_dependency 'bson_ext'
-  gem.add_development_dependency 'couch_potato'
-
-  gem.name = 'omniauth-identity'
-  gem.version = OmniAuth::Identity::VERSION
-  gem.description = %q{Internal authentication handlers for OmniAuth.}
-  gem.summary = gem.description
-  gem.email = ['michael@intridea.com']
-  gem.homepage = 'http://github.com/intridea/omniauth-identity'
-  gem.authors = ['Michael Bleigh']
-  gem.executables = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
-  gem.files = `git ls-files`.split("\n")
-  gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.require_paths = ['lib']
-  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6') if gem.respond_to? :required_rubygems_version=
-end

data/spec/omniauth/identity/models/data_mapper_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe(OmniAuth::Identity::Models::DataMapper, :db => true) do
-  class DataMapperTestIdentity
-    include DataMapper::Resource
-    include OmniAuth::Identity::Models::DataMapper
-
-    property :id,              Serial
-    auth_key :ham_sandwich
-  end
-
-  DataMapper.finalize
-
-  before :all do
-    @resource = DataMapperTestIdentity.new
-  end
-
-  it 'should delegate locate to the all query method' do
-    DataMapperTestIdentity.should_receive(:all).with('ham_sandwich' => 'open faced', 'category' => 'sandwiches').and_return(['wakka'])
-    DataMapperTestIdentity.locate('ham_sandwich' => 'open faced', 'category' => 'sandwiches').should == 'wakka'
-  end
-end

data/spec/omniauth/identity/models/mongo_mapper_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe(OmniAuth::Identity::Models::MongoMapper, :db => true) do
-  class MongoMapperTestIdentity
-    include MongoMapper::Document
-    include OmniAuth::Identity::Models::MongoMapper
-    auth_key :ham_sandwich
-  end
-
-
-  it 'should delegate locate to the where query method' do
-    MongoMapperTestIdentity.should_receive(:where).with('ham_sandwich' => 'open faced', 'category' => 'sandwiches').and_return(['wakka'])
-    MongoMapperTestIdentity.locate('ham_sandwich' => 'open faced', 'category' => 'sandwiches').should == 'wakka'
-  end
-end