/
config.rb
345 lines (314 loc) · 15.4 KB
/
config.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
module Authlogic
module Session
module Config # :nodoc:
def self.included(klass)
klass.extend(ClassMethods)
klass.send(:include, InstanceMethods)
end
# = Session Config
#
# This deals with configuration for your session. If you are wanting to configure your model please look at Authlogic::ORMAdapters::ActiveRecord::ActsAsAuthentic
#
# Configuration for your session is simple. The configuration options are just class methods. Just put this in your config/initializers directory
#
# UserSession.configure do |config|
# config.authenticate_with = User
# # ... more configuration
# end
#
# or you can set your configuration in the session class directly:
#
# class UserSession < Authlogic::Session::Base
# authenticate_with User
# # ... more configuration
# end
#
# You can also access the values in the same fashion:
#
# UserSession.authenticate_with
#
# See the methods belows for all configuration options.
module ClassMethods
# Lets you change which model to use for authentication.
#
# * <tt>Default:</tt> inferred from the class name. UserSession would automatically try User
# * <tt>Accepts:</tt> an ActiveRecord class
def authenticate_with(klass)
@klass_name = klass.name
@klass = klass
end
alias_method :authenticate_with=, :authenticate_with
# Convenience method that lets you easily set configuration, see examples above
def configure
yield self
end
# The name of the cookie or the key in the cookies hash. Be sure and use a unique name. If you have multiple sessions and they use the same cookie it will cause problems.
# Also, if a id is set it will be inserted into the beginning of the string. Exmaple:
#
# session = UserSession.new
# session.cookie_key => "user_credentials"
#
# session = UserSession.new(:super_high_secret)
# session.cookie_key => "super_high_secret_user_credentials"
#
# * <tt>Default:</tt> "#{klass_name.underscore}_credentials"
# * <tt>Accepts:</tt> String
def cookie_key(value = nil)
if value.nil?
read_inheritable_attribute(:cookie_key) || cookie_key("#{klass_name.underscore}_credentials")
else
write_inheritable_attribute(:cookie_key, value)
end
end
alias_method :cookie_key=, :cookie_key
# Authlogic tries to validate the credentials passed to it. One part of validation is actually finding the user and making sure it exists. What method it uses the do this is up to you.
#
# Let's say you have a UserSession that is authenticating a User. By default UserSession will call User.find_by_login(login). You can change what method UserSession calls by specifying it here. Then
# in your User model you can make that method do anything you want, giving you complete control of how users are found by the UserSession.
#
# Let's take an example: You want to allow users to login by username or email. Set this to the name of the class method that does this in the User model. Let's call it "find_by_username_or_email"
#
# class User < ActiveRecord::Base
# def self.find_by_username_or_email(login)
# find_by_username(login) || find_by_email(login)
# end
# end
#
# * <tt>Default:</tt> "find_by_#{login_field}"
# * <tt>Accepts:</tt> Symbol or String
def find_by_login_method(value = nil)
if value.nil?
read_inheritable_attribute(:find_by_login_method) || find_by_login_method("find_by_#{login_field}")
else
write_inheritable_attribute(:find_by_login_method, value)
end
end
alias_method :find_by_login_method=, :find_by_login_method
# Once the user confirms their openid Authlogic tries to find the record with that openod. This is the method it called on the record's
# class to find the record by the openid.
#
# * <tt>Default:</tt> "find_by_#{openid_field}"
# * <tt>Accepts:</tt> Symbol or String
def find_by_openid_method(value = nil)
if value.nil?
read_inheritable_attribute(:find_by_openid_method) || find_by_openid_method("find_by_#{openid_field}")
else
write_inheritable_attribute(:find_by_openid_method, value)
end
end
alias_method :find_by_openid_method=, :find_by_openid_method
# Calling UserSession.find tries to find the user session by session, then cookie, then params, and finally by basic http auth.
# This option allows you to change the order or remove any of these.
#
# * <tt>Default:</tt> [:session, :cookie, :params, :http_auth]
# * <tt>Accepts:</tt> Array, and can only use any of the 3 options above
def find_with(*values)
if values.blank?
read_inheritable_attribute(:find_with) || find_with(:session, :cookie, :params, :http_auth)
else
values.flatten!
write_inheritable_attribute(:find_with, values)
end
end
alias_method :find_with=, :find_with
# Every time a session is found the last_request_at field for that record is updatd with the current time, if that field exists. If you want to limit how frequent that field is updated specify the threshold
# here. For example, if your user is making a request every 5 seconds, and you feel this is too frequent, and feel a minute is a good threashold. Set this to 1.minute. Once a minute has passed in between
# requests the field will be updated.
#
# * <tt>Default:</tt> 0
# * <tt>Accepts:</tt> integer representing time in seconds
def last_request_at_threshold(value = nil)
if value.nil?
read_inheritable_attribute(:last_request_at_threshold) || last_request_at_threshold(0)
else
write_inheritable_attribute(:last_request_at_threshold, value)
end
end
alias_method :last_request_at_threshold=, :last_request_at_threshold
# The name of the method you want Authlogic to create for storing the login / username. Keep in mind this is just for your
# Authlogic::Session, if you want it can be something completely different than the field in your model. So if you wanted people to
# login with a field called "login" and then find users by email this is compeltely doable. See the find_by_login_method configuration
# option for more details.
#
# * <tt>Default:</tt> Guesses based on the model columns, tries login, username, and email. If none are present it defaults to login
# * <tt>Accepts:</tt> Symbol or String
def login_field(value = nil)
if value.nil?
read_inheritable_attribute(:login_field) || login_field(klass.login_field)
else
write_inheritable_attribute(:login_field, value)
end
end
alias_method :login_field=, :login_field
# The name of the method you want Authlogic to create for storing the openid url. Keep in mind this is just for your Authlogic::Session,
# if you want it can be something completely different than the field in your model. So if you wanted people to login with a field called
# "openid_url" and then find users by openid this is compeltely doable. See the find_by_openid_method configuration option for
# more details.
#
# * <tt>Default:</tt> Guesses based on the model columns, tries openid, openid_url, identity_url.
# * <tt>Accepts:</tt> Symbol or String
def openid_field(value = nil)
if value.nil?
read_inheritable_attribute(:openid_field) || openid_field((klass.column_names.include?("openid") && :openid) || (klass.column_names.include?("openid_url") && :openid_url) || (klass.column_names.include?("identity_url") && :identity_url))
else
write_inheritable_attribute(:openid_field, value)
end
end
alias_method :openid_field=, :openid_field
# The name of the method you want Authlogic to create for storing the openid url. Keep in mind this is just for your Authlogic::Session,
# if you want it can be something completely different than the field in your model. So if you wanted people to login with a field called
# "openid_url" and then find users by openid this is compeltely doable. See the find_by_openid_method configuration option for
# more details.
#
# * <tt>Default:</tt> Guesses based on the model columns, tries openid, openid_url, identity_url.
# * <tt>Accepts:</tt> Symbol or String
def openid_file_store_path(value = nil)
if value.nil?
read_inheritable_attribute(:openid_file_store_path) || openid_file_store_path((defined?(RAILS_ROOT) && RAILS_ROOT + "/tmp/openids") || (defined?(Merb) && Merb.root + "/tmp/openids"))
else
write_inheritable_attribute(:openid_file_store_path, value)
end
end
alias_method :openid_file_store_path=, :openid_file_store_path
# Works exactly like cookie_key, but for params. So a user can login via params just like a cookie or a session. Your URK would look like:
#
# http://www.domain.com?user_credentials=fdsfdfd32jfksdjfdksl
#
# You can change the "user_credentials" key above with this configuration option. Keep in mind, just like cookie_key, if you supply an id
# the id will be appended to the front.
#
# * <tt>Default:</tt> cookie_key
# * <tt>Accepts:</tt> String
def params_key(value = nil)
if value.nil?
read_inheritable_attribute(:params_key) || params_key(cookie_key)
else
write_inheritable_attribute(:params_key, value)
end
end
alias_method :params_key=, :params_key
# Works exactly like login_field, but for the password instead.
#
# * <tt>Default:</tt> Guesses based on the model columns, tries password and pass. If none are present it defaults to password
# * <tt>Accepts:</tt> Symbol or String
def password_field(value = nil)
if value.nil?
read_inheritable_attribute(:password_field) || password_field(klass.password_field)
else
write_inheritable_attribute(:password_field, value)
end
end
alias_method :password_field=, :password_field
# If sessions should be remembered by default or not.
#
# * <tt>Default:</tt> false
# * <tt>Accepts:</tt> Boolean
def remember_me(value = nil)
if value.nil?
read_inheritable_attribute(:remember_me)
else
write_inheritable_attribute(:remember_me, value)
end
end
alias_method :remember_me=, :remember_me
# The length of time until the cookie expires.
#
# * <tt>Default:</tt> 3.months
# * <tt>Accepts:</tt> Integer, length of time in seconds, such as 60 or 3.months
def remember_me_for(value = :_read)
if value == :_read
read_inheritable_attribute(:remember_me_for) || remember_me_for(3.months)
else
write_inheritable_attribute(:remember_me_for, value)
end
end
alias_method :remember_me_for=, :remember_me_for
# The name of the field that the remember token is stored. This is for cookies. Let's say you set up your app and want all users to be remembered for 6 months. Then you realize that might be a little too
# long. Well they already have a cookie set to expire in 6 months. Without a token you would have to reset their password, which obviously isn't feasible. So instead of messing with their password
# just reset their remember token. Next time they access the site and try to login via a cookie it will be rejected and they will have to relogin.
#
# * <tt>Default:</tt> Guesses based on the model columns, tries remember_token, remember_key, cookie_token, and cookie_key. If none are present it defaults to remember_token
# * <tt>Accepts:</tt> Symbol or String
def remember_token_field(value = nil)
if value.nil?
read_inheritable_attribute(:remember_token_field) || remember_token_field(klass.remember_token_field)
else
write_inheritable_attribute(:remember_token_field, value)
end
end
alias_method :remember_token_field=, :remember_token_field
# Works exactly like cookie_key, but for sessions. See cookie_key for more info.
#
# * <tt>Default:</tt> cookie_key
# * <tt>Accepts:</tt> Symbol or String
def session_key(value = nil)
if value.nil?
read_inheritable_attribute(:session_key) || session_key(cookie_key)
else
write_inheritable_attribute(:session_key, value)
end
end
alias_method :session_key=, :session_key
# The name of the method in your model used to verify the password. This should be an instance method. It should also be prepared to accept a raw password and a crytped password.
#
# * <tt>Default:</tt> "valid_#{password_field}?"
# * <tt>Accepts:</tt> Symbol or String
def verify_password_method(value = nil)
if value.nil?
read_inheritable_attribute(:verify_password_method) || verify_password_method("valid_#{password_field}?")
else
write_inheritable_attribute(:verify_password_method, value)
end
end
alias_method :verify_password_method=, :verify_password_method
end
module InstanceMethods # :nodoc:
def cookie_key
build_key(self.class.cookie_key)
end
def find_by_login_method
self.class.find_by_login_method
end
def find_by_openid_method
self.class.find_by_openid_method
end
def find_with
self.class.find_with
end
def last_request_at_threshold
self.class.last_request_at_threshold
end
def login_field
self.class.login_field
end
def openid_field
self.class.openid_field
end
def params_key
build_key(self.class.params_key)
end
def password_field
self.class.password_field
end
def remember_me_for
return unless remember_me?
self.class.remember_me_for
end
def remember_token_field
self.class.remember_token_field
end
def session_key
build_key(self.class.session_key)
end
def verify_password_method
self.class.verify_password_method
end
private
def build_key(last_part)
key_parts = [id, scope[:id], last_part].compact
key_parts.join("_")
end
end
end
end
end