challah 0.9.0.pre → 0.9.0

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-## Challah 0.9.0 (Unreleased)
+## Challah 0.9.0
 
 * Removed some legacy support for default login paths
 * Added authorizations table support. Shifting to flexible model for providers instead of always relying on username and password support.

data/db/migrate/20121116210759_create_authorizations.rb

@@ -5,6 +5,7 @@ class CreateAuthorizations < ActiveRecord::Migration
       t.string      :provider, limit: 50
       t.string      :uid
       t.string      :token, limit: 500
+      t.datetime    :expires_at
       t.datetime    :last_session_at
       t.string      :last_session_ip
       t.integer     :session_count, default: 0

data/lib/challah/authenticators/password.rb

@@ -2,7 +2,7 @@ module Challah
   module Authenticators
     class Password
       def self.match?(user, provider, plain_password)
-        if provider
+        if !!provider
           crypted_password = provider.fetch(:token)
           return Encrypter.compare(crypted_password, plain_password)
         end

data/lib/challah/authorization.rb

@@ -23,20 +23,30 @@ module Challah
         where(provider: provider, user_id: user_id).delete_all
       end
 
-      # Create a new authorization record for the given user
-      def set(options = {})
+      # Grab the user/provider record
+      def get(options = {})
         provider  = options.fetch(:provider)
         user_id   = options.fetch(:user_id)
-        uid       = options.fetch(:uid)
-        token     = options.fetch(:token)
+
+        where(provider: provider, user_id: user_id).first
+      end
+
+      # Create a new authorization record for the given user
+      def set(options = {})
+        provider    = options.fetch(:provider)
+        user_id     = options.fetch(:user_id).to_i
+        uid         = options.fetch(:uid)
+        token       = options.fetch(:token)
+        expires_at  = options.fetch(:expires_at, nil)
 
         del(options)
 
         create!({
-          provider: provider,
-          user_id:  user_id,
-          uid:      uid,
-          token:    token
+          provider:   provider,
+          user_id:    user_id,
+          uid:        uid,
+          token:      token,
+          expires_at: expires_at
         }, without_protection: true)
       end
     end

data/lib/challah/providers/password_provider.rb

@@ -1,11 +1,26 @@
 module Challah
   class PasswordProvider
+    def self.save(user)
+      set(uid: user.username, token: user.password, user_id: user.id)
+    end
+
     def self.set(options = {})
       user_id = options.fetch(:user_id)
       uid     = options.fetch(:uid, '')
       token   = options.fetch(:token, '')
 
-      token = Challah::Encrypter.encrypt(token)
+      if token.to_s.blank?
+        authorization = ::Authorization.get({
+          user_id:  user_id,
+          provider: :password
+        })
+
+        if authorization
+          token = authorization.token
+        end
+      else
+        token = Challah::Encrypter.encrypt(token)
+      end
 
       ::Authorization.set({
         provider: :password,
@@ -14,5 +29,11 @@ module Challah
         token:    token
       })
     end
+
+    def self.valid?(record)
+      password_validator = Challah.options[:password_validator]
+      password_validator.new(force: true).validate(record)
+      record.errors[:password].size.zero?
+    end
   end
 end

data/lib/challah/providers.rb

@@ -1,5 +1,10 @@
 module Challah
   module Providers
+    # Get a list of all authorization providers other than password provider
+    def custom_providers
+      providers.reject { |k, v| k == :password }
+    end
+
     # Register a new authorization provider.
     #
     # Usage:

data/lib/challah/signup.rb

@@ -0,0 +1,75 @@
+module Challah
+  class Signup
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    attr_reader :errors
+    attr_accessor :provider, :user
+
+    def initialize(attributes = {})
+      self.user = ::User.new
+      self.provider = :password
+      self.attributes = attributes
+      @errors = []
+    end
+
+    def attributes=(value)
+      return unless Hash === value
+
+      value.each do |key, value|
+        self.send("#{key}=", value)
+      end
+    end
+
+    def method_missing(method, *attrs)
+      user.send(method, *attrs)
+    end
+
+    def password=(value)
+      @provider = :password unless value.to_s.blank?
+      user.password = value
+    end
+
+    def valid_provider?
+      user.valid_provider?(provider)
+    end
+
+    def provider=(value)
+      if value.respond_to?(:to_sym)
+        @provider = value.to_sym
+      else
+        @provider = nil
+      end
+    end
+
+    def save
+      if valid?
+        user.save
+      else
+        false
+      end
+    end
+
+    def valid?
+      @errors = ActiveModel::Errors.new(user)
+
+      result = true
+
+      unless user.valid?
+        result = false
+        user.errors.each { |a, e| @errors.add(a, e) }
+      end
+
+      if !provider or !valid_provider?
+        result = false
+        user.errors.each { |a, e| @errors.add(a, e) unless @errors.added?(a, e) }
+      end
+
+      result
+    end
+
+    def self.model_name
+      ActiveModel::Name.new(Challah::Signup, Challah, "Signup")
+    end
+  end
+end

data/lib/challah/user/providers.rb

@@ -1,14 +1,29 @@
 module Challah::User
   module Providers
     def authorizations
+      return [] if new_record?
       ::Authorization.where(user_id: self.id)
     end
 
     def providers
-      @providers ||= authorizations.inject({}) do |hash, m|
+      return @providers if @providers
+
+      @providers = {}
+
+      # Grab providers from existing authorization records
+      @providers = authorizations.inject({}) do |hash, m|
         hash[m.provider.to_sym] = { id: m.id, uid: m.uid, token: m.token }
         hash
       end
+
+      # Then, grab any provider attributes provided
+      provider_attributes.each do |k, v|
+        if v.respond_to?(:fetch)
+          @providers[k] = v
+        end
+      end
+
+      @providers
     end
 
     # Does this user have the given provider name
@@ -19,5 +34,28 @@ module Challah::User
     def provider(provider_name)
       providers[provider_name.to_sym]
     end
+
+    def provider_attributes
+      @provider_attributes ||= Challah.providers.keys.inject({}) { |h, m| h[m] = nil; h }
+    end
+
+    def provider_attributes=(value)
+      if Hash === value
+        @provider_attributes = value.keys.inject({}) do |h, m|
+          h[m.to_sym] = (value[m].respond_to?(:symbolize_keys) ? value[m].symbolize_keys : value[m])
+          h
+        end
+      end
+    end
+
+    def valid_provider?(provider_name)
+      name = provider_name.to_sym
+
+      if Challah.providers.keys.include?(name)
+        Challah.providers[name].valid?(self)
+      else
+        false
+      end
+    end
   end
 end

data/lib/challah/user.rb

@@ -28,7 +28,8 @@ module Challah
         # Attributes
         ################################################################
 
-        attr_reader :password, :password_confirmation
+        attr_reader :password, :password_confirmation, :password_updated
+        attr_accessible :provider_attributes
 
         # Validation
         ################################################################
@@ -37,7 +38,7 @@ module Challah
         validates :first_name,      presence: true
         validates :last_name,       presence: true
 
-        validates_with Challah.options[:password_validator]
+        validates_with Challah.options[:password_validator], force: false
 
         # Scoped Finders
         ################################################################
@@ -49,7 +50,7 @@ module Challah
         ################################################################
 
         before_save :check_tokens
-        after_save  :check_for_password_updates
+        after_save  :save_updated_providers
         after_save  :clear_cache
         before_destroy :clear_authorizations
       end
@@ -73,18 +74,25 @@ module Challah
 
       protected
         # If password or username was changed, update the authorization record
-        def check_for_password_updates
+        def save_updated_providers
+          # Save password provider
           if @password_updated or @username_updated
-            Challah.providers[:password].set({
-              uid: username,
-              token: @password,
-              user_id: self.id
-            })
-
+            Challah.providers[:password].save(self)
             @password_updated = false
             @username_updated = false
             @password = nil
           end
+
+          # Save any other providers
+          Challah.custom_providers.each do |name, klass|
+            custom_provider_attributes = provider_attributes[name]
+
+            if custom_provider_attributes.respond_to?(:fetch)
+              if klass.valid?(self)
+                klass.save(self)
+              end
+            end
+          end
         end
 
         # Before a record is saved, make sure all tokens are set properly

data/lib/challah/validators/password_validator.rb

@@ -2,7 +2,7 @@ module Challah
   class PasswordValidator < ActiveModel::Validator
     # Check to make sure a valid password and confirmation were set
     def validate(record)
-      if record.password_provider?
+      if record.password_provider? or options[:force]
         if record.new_record? and record.password.to_s.blank? and !record.password_changed?
           record.errors.add :password, :blank
         elsif record.password_changed?

data/lib/challah/version.rb

@@ -1,3 +1,3 @@
 module Challah
-  VERSION = "0.9.0.pre" unless defined?(::Challah::VERSION)
+  VERSION = "0.9.0" unless defined?(::Challah::VERSION)
 end

data/lib/challah.rb

@@ -13,6 +13,7 @@ module Challah
   autoload :Providers,                        'challah/providers'
   autoload :Random,                           'challah/random'
   autoload :Session,                          'challah/session'
+  autoload :Signup,                           'challah/signup'
   autoload :Techniques,                       'challah/techniques'
   autoload :Techniques,                       'challah/techniques'
 

data/test/helper.rb

@@ -15,7 +15,7 @@ require "#{sample_root}/config/environment"
 
 # Some other dependencies for testing w/ shoulda and factory girl
 require 'shoulda'
-require 'mocha/setup'
+require 'mocha'
 require 'factory_girl'
 require 'factories'
 require 'rails/test_help'
@@ -104,6 +104,31 @@ class MockRequest
   end
 end
 
+class FakeProvider
+  def self.save(record)
+    set(record.fake_provider.merge(user_id: record.id))
+  end
+
+  def self.set(options = {})
+    user_id = options.fetch(:user_id)
+    uid     = options.fetch(:uid, '')
+    token   = options.fetch(:token, '')
+
+    Authorization.set({
+      provider: :fake,
+      user_id:  user_id,
+      uid:      uid,
+      token:    token
+    })
+  end
+
+  def self.valid?(record)
+    record.fake_provider? and record.fake_provider.fetch(:token) == 'me'
+  end
+end
+
+Challah.register_provider :fake, FakeProvider
+
 # Monkey patch fix for shoulda and Rails 3.1+.
 module Shoulda
   module ActiveRecord

data/test/signup_test.rb

@@ -0,0 +1,122 @@
+require 'helper'
+
+class SignupTest < ActiveSupport::TestCase
+  context "A signup instance" do
+    should "be properly named" do
+      assert_equal "Signup", Challah::Signup.model_name
+    end
+  end
+
+  context "A user" do
+    should "sign up for an app with a password" do
+      signup = Challah::Signup.new
+      signup.first_name             = 'Avon'
+      signup.last_name              = 'Barksdale'
+      signup.email                  = 'avon@challah.me'
+      signup.password               = 'test123'
+      signup.password_confirmation  = 'test123'
+
+      assert_difference [ 'User.count', 'Authorization.count' ], 1 do
+        assert signup.save, 'Signup could not save!'
+      end
+
+      assert_equal false, signup.new_record?
+      assert_equal "Avon Barksdale", signup.user.name
+      assert_equal true, signup.user.authenticate_with_password('test123')
+      assert_equal :password, signup.provider
+    end
+
+    should "sign up using a params hash" do
+      user_params = {
+        first_name: 'Stringer',
+        last_name:  'Bell',
+        email:      'stringer@challah.me',
+        password:   'abc123',
+        password_confirmation: 'abc123'
+      }
+
+      signup = Challah::Signup.new(user_params)
+
+      assert_difference [ 'User.count', 'Authorization.count' ], 1 do
+        assert signup.save, 'Signup could not save'
+      end
+
+      assert_equal false, signup.new_record?
+      assert_equal 'Stringer Bell', signup.user.name
+      assert_equal true, signup.user.authenticate_with_password('abc123')
+    end
+
+    should "not sign up without a password" do
+      signup = Challah::Signup.new
+      signup.first_name   = 'Avon'
+      signup.last_name    = 'Barksdale'
+      signup.email        = 'avon@challah.me'
+
+      assert_no_difference [ 'User.count', 'Authorization.count' ] do
+        assert_equal false, signup.save
+      end
+
+      assert_equal true, signup.new_record?
+      assert_equal "Avon Barksdale", signup.user.name
+      assert_equal :password, signup.provider
+    end
+
+    should "sign up with another valid provider" do
+      signup = Challah::Signup.new
+      signup.first_name   = 'Avon'
+      signup.last_name    = 'Barksdale'
+      signup.email        = 'avon@challah.me'
+      signup.provider     = "fake"
+      signup.password     = ""
+      signup.password_confirmation = ""
+      signup.provider_attributes = { "fake" => { "uid" => "1", "token" => "me" } }
+
+      assert_difference [ 'User.count', 'Authorization.count' ], 1 do
+        assert signup.save, 'Signup could not save'
+      end
+
+      assert_equal :fake, signup.provider
+      assert_equal "me", signup.user.providers[:fake].fetch(:token)
+    end
+
+    should "not sign up without any providers" do
+      signup = Challah::Signup.new
+      signup.first_name   = 'Avon'
+      signup.last_name    = 'Barksdale'
+      signup.email        = 'avon@challah.me'
+      signup.provider     = nil
+
+      assert_no_difference [ 'User.count', 'Authorization.count' ] do
+        assert_equal false, signup.save
+      end
+
+      assert_equal true, signup.new_record?
+      assert_equal "Avon Barksdale", signup.user.name
+      assert_equal nil, signup.provider
+    end
+
+    should "not sign up with an invalid provider" do
+      signup = Challah::Signup.new
+      signup.first_name   = 'Avon'
+      signup.last_name    = 'Barksdale'
+      signup.email        = 'avon@challah.me'
+      signup.provider     = "blank"
+      signup.provider_attributes = { "blank" => { "uid" => "1", "token" => "1" } }
+
+      assert_no_difference [ 'User.count', 'Authorization.count' ], 1 do
+        assert_equal false, signup.save
+      end
+
+      assert_equal true, signup.new_record?
+      assert_equal "Avon Barksdale", signup.user.name
+      assert_equal :blank, signup.provider
+    end
+
+    should "consolidate error messages" do
+      signup = Challah::Signup.new
+      assert_equal false, signup.save
+      expected_error_fields = [ :first_name, :last_name, :email, :password ].sort
+      assert_equal expected_error_fields, signup.errors.messages.keys.sort
+    end
+  end
+end

data/test/user_test.rb

@@ -188,6 +188,29 @@ class UserTest < ActiveSupport::TestCase
       assert_equal false, user.authenticate(:blah, 'sdsd', 'sdlsk')
     end
 
+    should "be able to change a username" do
+      user = create(:user)
+
+      user.password!('test123')
+      user.username = 'john'
+      user.save
+
+      # reload
+      user = User.find_by_id(user.id)
+
+      assert_equal true, user.authenticate('test123')
+      assert_equal 'john', user.username
+
+      user.username = 'johndoe'
+      user.save
+
+      # reload
+      user = User.find_by_id(user.id)
+
+      assert_equal true, user.authenticate('test123')
+      assert_equal 'johndoe', user.username
+    end
+
     should "have successful and failed authentication methods" do
       user = create(:user)
 
@@ -272,5 +295,37 @@ class UserTest < ActiveSupport::TestCase
         end
       end
     end
+
+    should "set provider attributes" do
+      user = build(:user)
+
+      user.provider_attributes = {
+        :fake => { :uid => "1", "token" => 'me' }
+      }
+
+      assert_equal true, user.provider?(:fake)
+      assert_equal true, user.valid_provider?(:fake)
+
+      assert_difference [ 'User.count', 'Authorization.count' ], 1 do
+        assert user.save
+      end
+    end
+
+    should "not add invalid providers" do
+      provider_attributes = {
+        "fake" => { :uid => "1", "token" => 'not-me' }
+      }
+
+      user = build(:user, :provider_attributes => provider_attributes)
+
+      assert_equal true, user.provider?(:fake)
+      assert_equal false, user.valid_provider?(:fake)
+
+      assert_difference [ 'User.count' ], 1 do
+        assert_no_difference [ 'Authorization.count' ] do
+          assert user.save
+        end
+      end
+    end
   end
 end

data/vendor/bundle/bin/convert_to_should_syntax

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'shoulda-context' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first
+  str = ARGV.first
+  str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
+  if str =~ /\A_(.*)_\z/
+    version = $1
+    ARGV.shift
+  end
+end
+
+gem 'shoulda-context', version
+load Gem.bin_path('shoulda-context', 'convert_to_should_syntax', version)

data/vendor/bundle/bin/erubis

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'erubis' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first
+  str = ARGV.first
+  str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
+  if str =~ /\A_(.*)_\z/
+    version = $1
+    ARGV.shift
+  end
+end
+
+gem 'erubis', version
+load Gem.bin_path('erubis', 'erubis', version)

data/vendor/bundle/bin/rackup

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'rack' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first
+  str = ARGV.first
+  str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
+  if str =~ /\A_(.*)_\z/
+    version = $1
+    ARGV.shift
+  end
+end
+
+gem 'rack', version
+load Gem.bin_path('rack', 'rackup', version)

data/vendor/bundle/bin/rails

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'railties' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first
+  str = ARGV.first
+  str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
+  if str =~ /\A_(.*)_\z/
+    version = $1
+    ARGV.shift
+  end
+end
+
+gem 'railties', version
+load Gem.bin_path('railties', 'rails', version)

data/vendor/bundle/bin/rake

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first
+  str = ARGV.first
+  str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
+  if str =~ /\A_(.*)_\z/
+    version = $1
+    ARGV.shift
+  end
+end
+
+gem 'rake', version
+load Gem.bin_path('rake', 'rake', version)