omniauth-identity 1.0.0.rc1 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ae0c6e9acba482e20f1284d42f157beb243b7efe00913b420e1d97ee158d0d2
+  data.tar.gz: c113d2a6e9f701ae8b7a524e7aede16bfce000f593f194e577b38a2cb02a10c0
+SHA512:
+  metadata.gz: 4f8cbd06676c3b16661651bf161e4bf819e8b48529aec572d2a7ddb52e5a4dde87bf52e71933be86af22486f03b4a4d5710417db79803b1bba93357258122330
+  data.tar.gz: 36a5d520208b6d0754d5d3e7fb7990b27b9bd967b598039bf6d37bf0e8167e2e8c7689df79a8aeee9a6d9187b2a1d2653d02e99025444157183d0072323807ae

data/.gitignore

@@ -1,4 +1,6 @@
 /coverage
 /pkg
 /doc
-
+Gemfile.lock
+/.ruby-version
+/.ruby-gemset

data/.rspec

@@ -1,2 +1,3 @@
---format=nested
+--require spec_helper
+--format=documentation
 --colour

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0] - 2020-09-01
+
+### Added 
+- CHANGELOG to maintain a history of changes.
+- Include mongoid-rspec gem.
+
+### Changed
+- Fix failing Specs
+- Update Spec syntax to RSpec 3
+- Fix deprecation Warnings
+- Updated mongoid_spec.rb to leverage mongoid-rspec features.
+- Fix security warning about missing secret in session cookie.
+- Dependency version limits so that the most up-to-date gem dependencies are used. (rspec 3+, mongo 2+, mongoid 7+, rake 13+, rack 2+, json 2+)
+- Updated copyright information.
+- Updated MongoMapper section of README to reflect its discontinued support.
+
+### Removed
+- Gemfile.lock file
+- MongoMapper support; unable to satisfy dependencies of both MongoMapper and Mongoig now that MongoMapper is no longer actively maintained.

data/Gemfile

@@ -1,8 +1,10 @@
 source "http://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 gemspec
 
 group :development, :test do
+  gem 'mongoid-rspec', github: 'mongoid/mongoid-rspec'
   gem 'guard'
   gem 'guard-rspec'
   gem 'guard-bundler'

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2020- Andrew Roberts, and Jellybooks Ltd.
+Copyright (c) 2010-2015 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.

data/README.markdown

@@ -8,26 +8,103 @@ basic construct for user management and then gets out of the way.
 
 ## Usage
 
-You use `oa-identity` just like you would any other OmniAuth provider: as a
+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:
 
-    use OmniAuth::Builder do
-      provider :identity, :fields => [:email]
-    end
+```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. You just
-need to subclass the relevant class:
+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
+
+Unfortunately MongoMapper is **not supported** in `omniauth-identity` from >= v2.0 as a result of it 
+not being maintained for several years.
+
+It wasn't possible to include Mongoid *and* MongoMapper due to incompatible gem version 
+requirements. Therefore precedence was given to Mongoid as it is significantly more 
+popular and actively maintained. 
+
+### 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
 
-    class Identity < OmniAuth::Identity::Models::ActiveRecord
-      # Add whatever you like!
-    end
+  attr_accessor :password_confirmation
 
-Adapters are provided for `ActiveRecord` and `MongoMapper` and are
-autoloaded on request (but not loaded by default so no dependencies are
-injected).
+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
@@ -42,9 +119,11 @@ Simple!
 To use a class other than the default, specify the <tt>:model</tt> option to a
 different class.
 
-    use OmniAuth::Builder do
-      provider :identity, :fields => [:email], :model => MyCustomClass
-    end
+```ruby
+use OmniAuth::Builder do
+  provider :identity, :fields => [:email], :model => MyCustomClass
+end
+```
 
 ## Customizing Registration Failure
 
@@ -52,39 +131,74 @@ To use your own custom registration form, create a form that POSTs to
 '/auth/identity/register' with 'password', 'password_confirmation', and your
 other fields.
 
-    <%= 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 %>
+```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>.
 
-    <%= 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 %>
+```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.
 
-    use OmniAuth::Builder do
-      provider :identity,
-        :fields => [:email],
-        :on_failed_registration => UsersController.action(:new)
-    end
+```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!
+
+## License
+
+MIT License. See LICENSE for details.
+
+## Copyright
+
+Copyright (c) 2020- Andrew Roberts, and Jellybooks Ltd.
+Copyright (c) 2010-2015 Michael Bleigh, and Intridea, Inc.

data/lib/omniauth-identity/version.rb

@@ -1,5 +1,5 @@
 module OmniAuth
   module Identity
-    VERSION = '1.0.0.rc1'
+    VERSION = '2.0.0'
   end
 end

data/lib/omniauth/identity.rb

@@ -6,12 +6,13 @@ module OmniAuth
   end
 
   module Identity
-    autoload :Model,            'omniauth/identity/model'
-    autoload :SecurePassword,   'omniauth/identity/secure_password'
+    autoload :Model,               'omniauth/identity/model'
+    autoload :SecurePassword,      'omniauth/identity/secure_password'
     module Models
-      autoload :ActiveRecord,   'omniauth/identity/models/active_record'
-      # autoload :MongoMapper,  'omniauth/identity/models/mongo_mapper'
-      autoload :Mongoid,        'omniauth/identity/models/mongoid'
+      autoload :ActiveRecord,      'omniauth/identity/models/active_record'
+      autoload :Mongoid,           'omniauth/identity/models/mongoid'
+      autoload :DataMapper,        'omniauth/identity/models/data_mapper'
+      autoload :CouchPotatoModule, 'omniauth/identity/models/couch_potato'
     end
   end
 end

data/lib/omniauth/identity/model.rb

@@ -23,14 +23,14 @@ module OmniAuth
         # Authenticate a user with the given key and password.
         #
         # @param [String] key The unique login key provided for a given identity.
-        # @param [String] password The presumed password for the identity. 
+        # @param [String] password The presumed password for the identity.
         # @return [Model] An instance of the identity model class.
-        def authenticate(key, password)
-          instance = locate(key)
+        def authenticate(conditions, password)
+          instance = locate(conditions)
           return false unless instance
           instance.authenticate(password)
         end
-        
+
         # Used to set or retrieve the method that will be used to get
         # and set the user-supplied authentication key.
         # @return [String] The method name.
@@ -75,7 +75,7 @@ module OmniAuth
       #
       # @return [String] An identifier string unique to this identity.
       def uid
-        if respond_to?('id')
+        if respond_to?(:id)
           return nil if self.id.nil?
           self.id.to_s
         else
@@ -90,7 +90,7 @@ module OmniAuth
       # @return [String] An identifying string that will be entered by
       #   users upon sign in.
       def auth_key
-        if respond_to?(self.class.auth_key)
+        if respond_to?(self.class.auth_key.to_sym)
           send(self.class.auth_key)
         else
           raise NotImplementedError
@@ -104,8 +104,9 @@ module OmniAuth
       # @param [String] value The value to which the auth key should be
       #   set.
       def auth_key=(value)
-        if respond_to?(self.class.auth_key + '=')
-          send(self.class.auth_key + '=', value)
+        auth_key_setter = (self.class.auth_key + '=').to_sym
+        if respond_to?(auth_key_setter)
+          send(auth_key_setter, value)
         else
           raise NotImplementedError
         end

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

@@ -9,14 +9,14 @@ module OmniAuth
 
         self.abstract_class = true
         has_secure_password
-       
+
         def self.auth_key=(key)
           super
           validates_uniqueness_of key, :case_sensitive => false
         end
 
-        def self.locate(key)
-          where(auth_key => key).first
+        def self.locate(search_hash)
+          where(search_hash).first
         end
       end
     end

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

@@ -0,0 +1,31 @@
+require 'couch_potato'
+
+module OmniAuth
+  module Identity
+    module Models
+      # can not be named CouchPotato since there is a class with that name
+      module CouchPotatoModule
+
+        def self.included(base)
+
+          base.class_eval do
+
+            include ::OmniAuth::Identity::Model
+            include ::OmniAuth::Identity::SecurePassword
+
+            has_secure_password
+
+            def self.auth_key=(key)
+              super
+              validates_uniqueness_of key, :case_sensitive => false
+            end
+
+            def self.locate(search_hash)
+              where(search_hash).first
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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