Andreas/tracks
1
0
Fork 0
mirror of https://github.com/TracksApp/tracks.git synced 2026-04-18 10:09:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

freeze rails 2.3.9

Browse source
This commit is contained in:
Reinier Balt 2010-09-27 21:04:01 +02:00
parent ee751a5ced
commit 6b95deef85
1916 changed files with 240923 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

12
vendor/rails/activemodel/CHANGES vendored Normal file
View file

@ -0,0 +1,12 @@
Changes from extracting bits to ActiveModel
* ActiveModel::Observer#add_observer!
It has a custom hook to define after_find that should really be in a
ActiveRecord::Observer subclass:
def add_observer!(klass)
klass.add_observer(self)
klass.class_eval 'def after_find() end' unless
klass.respond_to?(:after_find)
end

21
vendor/rails/activemodel/README vendored Normal file
View file

@ -0,0 +1,21 @@
Active Model
==============
Totally experimental library that aims to extract common model mixins from
ActiveRecord for use in ActiveResource (and other similar libraries).
This is in a very rough state (no autotest or spec rake tasks set up yet),
so please excuse the mess.
Here's what I plan to extract:
* ActiveModel::Observing
* ActiveModel::Callbacks
* ActiveModel::Validations
# for ActiveResource params and ActiveRecord options
* ActiveModel::Scoping
# to_json, to_xml, etc
* ActiveModel::Serialization
I'm trying to keep ActiveRecord compatibility where possible, but I'm
annotating the spots where I'm diverging a bit.

24
vendor/rails/activemodel/Rakefile vendored Executable file
View file

@ -0,0 +1,24 @@
#!/usr/bin/env ruby
require 'rake'
require 'rake/testtask'
require 'rake/rdoctask'
task :default => :test
Rake::TestTask.new do |t|
t.libs << "test"
t.pattern = 'test/**/*_test.rb'
t.verbose = true
t.warning = true
end
# Generate the RDoc documentation
Rake::RDocTask.new do |rdoc|
rdoc.rdoc_dir = 'doc'
rdoc.title = "Active Model"
rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
rdoc.options << '--charset' << 'utf-8'
rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : '../doc/template/horo'
rdoc.rdoc_files.include('README', 'CHANGES')
rdoc.rdoc_files.include('lib/**/*.rb')
end

5
vendor/rails/activemodel/lib/active_model.rb vendored Normal file
View file

@ -0,0 +1,5 @@
require 'active_model/observing'
# disabled until they're tested
# require 'active_model/callbacks'
# require 'active_model/validations'
require 'active_model/base'

8
vendor/rails/activemodel/lib/active_model/base.rb vendored Normal file
View file

@ -0,0 +1,8 @@
module ActiveModel
class Base
include Observing
# disabled, until they're tested
# include Callbacks
# include Validations
end
end

7
vendor/rails/activemodel/lib/active_model/callbacks.rb vendored Normal file
View file

@ -0,0 +1,7 @@
require 'active_model/core'
module ActiveModel
module Callbacks
end
end

7
vendor/rails/activemodel/lib/active_model/core.rb vendored Normal file
View file

@ -0,0 +1,7 @@
# This file is required by each major ActiveModel component for the core requirements. This allows you to
# load individual pieces of ActiveModel as needed.
$LOAD_PATH << File.join(File.dirname(__FILE__), '..', '..', '..', 'activesupport', 'lib')
# premature optimization?
# So far, we only need the string inflections and not the rest of ActiveSupport.
require 'active_support/inflector'

38
vendor/rails/activemodel/lib/active_model/deprecated_error_methods.rb vendored Normal file
View file

@ -0,0 +1,38 @@
module ActiveModel
module DeprecatedErrorMethods
def on(attribute)
ActiveSupport::Deprecation.warn "Errors#on have been deprecated, use Errors#[] instead"
self[attribute]
end
def on_base
ActiveSupport::Deprecation.warn "Errors#on_base have been deprecated, use Errors#[:base] instead"
on(:base)
end
def add(attribute, msg = Errors.default_error_messages[:invalid])
ActiveSupport::Deprecation.warn "Errors#add(attribute, msg) has been deprecated, use Errors#[attribute] << msg instead"
self[attribute] << msg
end
def add_to_base(msg)
ActiveSupport::Deprecation.warn "Errors#add_to_base(msg) has been deprecated, use Errors#[:base] << msg instead"
self[:base] << msg
end
def invalid?(attribute)
ActiveSupport::Deprecation.warn "Errors#invalid?(attribute) has been deprecated, use Errors#[attribute].any? instead"
self[attribute].any?
end
def full_messages
ActiveSupport::Deprecation.warn "Errors#full_messages has been deprecated, use Errors#to_a instead"
to_a
end
def each_full
ActiveSupport::Deprecation.warn "Errors#each_full has been deprecated, use Errors#to_a.each instead"
to_a.each { |error| yield error }
end
end
end

82
vendor/rails/activemodel/lib/active_model/errors.rb vendored Normal file
View file

@ -0,0 +1,82 @@
module ActiveModel
class Errors < Hash
include DeprecatedErrorMethods
@@default_error_messages = {
:inclusion => "is not included in the list",
:exclusion => "is reserved",
:invalid => "is invalid",
:confirmation => "doesn't match confirmation",
:accepted => "must be accepted",
:empty => "can't be empty",
:blank => "can't be blank",
:too_long => "is too long (maximum is %d characters)",
:too_short => "is too short (minimum is %d characters)",
:wrong_length => "is the wrong length (should be %d characters)",
:taken => "has already been taken",
:not_a_number => "is not a number",
:greater_than => "must be greater than %d",
:greater_than_or_equal_to => "must be greater than or equal to %d",
:equal_to => "must be equal to %d",
:less_than => "must be less than %d",
:less_than_or_equal_to => "must be less than or equal to %d",
:odd => "must be odd",
:even => "must be even"
}
##
# :singleton-method:
# Holds a hash with all the default error messages that can be replaced by your own copy or localizations.
cattr_accessor :default_error_messages
alias_method :get, :[]
alias_method :set, :[]=
def [](attribute)
if errors = get(attribute.to_sym)
errors.size == 1 ? errors.first : errors
else
set(attribute.to_sym, [])
end
end
def []=(attribute, error)
self[attribute.to_sym] << error
end
def each
each_key do |attribute|
self[attribute].each { |error| yield attribute, error }
end
end
def size
values.flatten.size
end
def to_a
inject([]) do |errors_with_attributes, (attribute, errors)|
if error.blank?
errors_with_attributes
else
if attr == :base
errors_with_attributes << error
else
errors_with_attributes << (attribute.to_s.humanize + " " + error)
end
end
end
end
def to_xml(options={})
options[:root] ||= "errors"
options[:indent] ||= 2
options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
options[:builder].instruct! unless options.delete(:skip_instruct)
options[:builder].errors do |e|
to_a.each { |error| e.error(error) }
end
end
end
end

98
vendor/rails/activemodel/lib/active_model/observing.rb vendored Normal file
View file

@ -0,0 +1,98 @@
require 'observer'
require 'singleton'
require 'active_model/core'
module ActiveModel
module Observing
module ClassMethods
def observers
@observers ||= []
end
def observers=(*values)
@observers = values.flatten
end
def instantiate_observers
observers.each { |o| instantiate_observer(o) }
end
protected
def instantiate_observer(observer)
# string/symbol
if observer.respond_to?(:to_sym)
observer = observer.to_s.camelize.constantize.instance
elsif observer.respond_to?(:instance)
observer.instance
else
raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
end
end
# Notify observers when the observed class is subclassed.
def inherited(subclass)
super
changed
notify_observers :observed_class_inherited, subclass
end
end
def self.included(receiver)
receiver.extend Observable, ClassMethods
end
end
class Observer
include Singleton
attr_writer :observed_classes
class << self
attr_accessor :models
# Attaches the observer to the supplied model classes.
def observe(*models)
@models = models.flatten
@models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model }
end
def observed_class_name
@observed_class_name ||=
if guessed_name = name.scan(/(.*)Observer/)[0]
@observed_class_name = guessed_name[0]
end
end
# The class observed by default is inferred from the observer's class name:
# assert_equal [Person], PersonObserver.observed_class
def observed_class
if observed_class_name
observed_class_name.constantize
else
nil
end
end
end
# Start observing the declared classes and their subclasses.
def initialize
self.observed_classes = self.class.models if self.class.models
observed_classes.each { |klass| klass.add_observer(self) }
end
# Send observed_method(object) if the method exists.
def update(observed_method, object) #:nodoc:
send(observed_method, object) if respond_to?(observed_method)
end
# Special method sent by the observed class when it is inherited.
# Passes the new subclass.
def observed_class_inherited(subclass) #:nodoc:
self.class.observe(observed_classes + [subclass])
subclass.add_observer(self)
end
protected
def observed_classes
@observed_classes ||= [self.class.observed_class]
end
end
end

68
vendor/rails/activemodel/lib/active_model/state_machine.rb vendored Normal file
View file

@ -0,0 +1,68 @@
module ActiveModel
module StateMachine
class InvalidTransition < Exception
end
def self.included(base)
require 'active_model/state_machine/machine'
base.extend ClassMethods
end
module ClassMethods
def inherited(klass)
super
klass.state_machines = state_machines
end
def state_machines
@state_machines ||= {}
end
def state_machines=(value)
@state_machines = value ? value.dup : nil
end
def state_machine(name = nil, options = {}, &block)
if name.is_a?(Hash)
options = name
name = nil
end
name ||= :default
state_machines[name] ||= Machine.new(self, name)
block ? state_machines[name].update(options, &block) : state_machines[name]
end
def define_state_query_method(state_name)
name = "#{state_name}?"
undef_method(name) if method_defined?(name)
class_eval "def #{name}; current_state.to_s == %(#{state_name}) end"
end
end
def current_state(name = nil, new_state = nil, persist = false)
sm = self.class.state_machine(name)
ivar = sm.current_state_variable
if name && new_state
if persist && respond_to?(:write_state)
write_state(sm, new_state)
end
if respond_to?(:write_state_without_persistence)
write_state_without_persistence(sm, new_state)
end
instance_variable_set(ivar, new_state)
else
instance_variable_set(ivar, nil) unless instance_variable_defined?(ivar)
value = instance_variable_get(ivar)
return value if value
if respond_to?(:read_state)
value = instance_variable_set(ivar, read_state(sm))
end
value || sm.initial_state
end
end
end
end

64
vendor/rails/activemodel/lib/active_model/state_machine/event.rb vendored Normal file
View file

@ -0,0 +1,64 @@
require 'active_model/state_machine/state_transition'
module ActiveModel
module StateMachine
class Event
attr_reader :name, :success
def initialize(machine, name, options = {}, &block)
@machine, @name, @transitions = machine, name, []
if machine
machine.klass.send(:define_method, "#{name}!") do |*args|
machine.fire_event(name, self, true, *args)
end
machine.klass.send(:define_method, name.to_s) do |*args|
machine.fire_event(name, self, false, *args)
end
end
update(options, &block)
end
def fire(obj, to_state = nil, *args)
transitions = @transitions.select { |t| t.from == obj.current_state(@machine ? @machine.name : nil) }
raise InvalidTransition if transitions.size == 0
next_state = nil
transitions.each do |transition|
next if to_state && !Array(transition.to).include?(to_state)
if transition.perform(obj)
next_state = to_state || Array(transition.to).first
transition.execute(obj, *args)
break
end
end
next_state
end
def transitions_from_state?(state)
@transitions.any? { |t| t.from? state }
end
def ==(event)
if event.is_a? Symbol
name == event
else
name == event.name
end
end
def update(options = {}, &block)
if options.key?(:success) then @success = options[:success] end
if block then instance_eval(&block) end
self
end
private
def transitions(trans_opts)
Array(trans_opts[:from]).each do |s|
@transitions << StateTransition.new(trans_opts.merge({:from => s.to_sym}))
end
end
end
end
end

78
vendor/rails/activemodel/lib/active_model/state_machine/machine.rb vendored Normal file
View file

@ -0,0 +1,78 @@
require 'active_model/state_machine/state'
require 'active_model/state_machine/event'
module ActiveModel
module StateMachine
class Machine
attr_writer :initial_state
attr_accessor :states, :events, :state_index
attr_reader :klass, :name
def initialize(klass, name, options = {}, &block)
@klass, @name, @states, @state_index, @events = klass, name, [], {}, {}
update(options, &block)
end
def initial_state
@initial_state ||= (states.first ? states.first.name : nil)
end
def update(options = {}, &block)
if options.key?(:initial) then @initial_state = options[:initial] end
if block then instance_eval(&block) end
self
end
def fire_event(event, record, persist, *args)
state_index[record.current_state(@name)].call_action(:exit, record)
if new_state = @events[event].fire(record, *args)
state_index[new_state].call_action(:enter, record)
if record.respond_to?(event_fired_callback)
record.send(event_fired_callback, record.current_state, new_state)
end
record.current_state(@name, new_state, persist)
record.send(@events[event].success) if @events[event].success
true
else
if record.respond_to?(event_failed_callback)
record.send(event_failed_callback, event)
end
false
end
end
def states_for_select
states.map { |st| [st.display_name, st.name.to_s] }
end
def events_for(state)
events = @events.values.select { |event| event.transitions_from_state?(state) }
events.map! { |event| event.name }
end
def current_state_variable
"@#{@name}_current_state"
end
private
def state(name, options = {})
@states << (state_index[name] ||= State.new(name, :machine => self)).update(options)
end
def event(name, options = {}, &block)
(@events[name] ||= Event.new(self, name)).update(options, &block)
end
def event_fired_callback
@event_fired_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_fired'
end
def event_failed_callback
@event_failed_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_failed'
end
end
end
end

47
vendor/rails/activemodel/lib/active_model/state_machine/state.rb vendored Normal file
View file

@ -0,0 +1,47 @@
module ActiveModel
module StateMachine
class State
attr_reader :name, :options
def initialize(name, options = {})
@name = name
if machine = options.delete(:machine)
machine.klass.define_state_query_method(name)
end
update(options)
end
def ==(state)
if state.is_a? Symbol
name == state
else
name == state.name
end
end
def call_action(action, record)
action = @options[action]
case action
when Symbol, String
record.send(action)
when Proc
action.call(record)
end
end
def display_name
@display_name ||= name.to_s.gsub(/_/, ' ').capitalize
end
def for_select
[display_name, name.to_s]
end
def update(options = {})
if options.key?(:display) then @display_name = options.delete(:display) end
@options = options
self
end
end
end
end

40
vendor/rails/activemodel/lib/active_model/state_machine/state_transition.rb vendored Normal file
View file

@ -0,0 +1,40 @@
module ActiveModel
module StateMachine
class StateTransition
attr_reader :from, :to, :options
def initialize(opts)
@from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
@options = opts
end
def perform(obj)
case @guard
when Symbol, String
obj.send(@guard)
when Proc
@guard.call(obj)
else
true
end
end
def execute(obj, *args)
case @on_transition
when Symbol, String
obj.send(@on_transition, *args)
when Proc
@on_transition.call(obj, *args)
end
end
def ==(obj)
@from == obj.from && @to == obj.to
end
def from?(value)
@from == value
end
end
end
end

126
vendor/rails/activemodel/lib/active_model/validations.rb vendored Normal file
View file

@ -0,0 +1,126 @@
require 'active_model/core'
module ActiveModel
module Validations
def self.included(base) # :nodoc:
base.extend(ClassMethods)
base.__send__(:include, ActiveSupport::Callbacks)
base.define_callbacks :validate, :validate_on_create, :validate_on_update
end
module ClassMethods
DEFAULT_VALIDATION_OPTIONS = { :on => :save, :allow_nil => false, :allow_blank => false, :message => nil }.freeze
# Adds a validation method or block to the class. This is useful when
# overriding the +validate+ instance method becomes too unwieldly and
# you're looking for more descriptive declaration of your validations.
#
# This can be done with a symbol pointing to a method:
#
# class Comment < ActiveRecord::Base
# validate :must_be_friends
#
# def must_be_friends
# errors.add_to_base("Must be friends to leave a comment") unless commenter.friend_of?(commentee)
# end
# end
#
# Or with a block which is passed the current record to be validated:
#
# class Comment < ActiveRecord::Base
# validate do |comment|
# comment.must_be_friends
# end
#
# def must_be_friends
# errors.add_to_base("Must be friends to leave a comment") unless commenter.friend_of?(commentee)
# end
# end
#
# This usage applies to +validate_on_create+ and +validate_on_update as well+.
#
# Validates each attribute against a block.
#
# class Person < ActiveRecord::Base
# validates_each :first_name, :last_name do |record, attr, value|
# record.errors.add attr, 'starts with z.' if value[0] == ?z
# end
# end
#
# Options:
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
# * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_each(*attrs)
options = attrs.extract_options!.symbolize_keys
attrs = attrs.flatten
# Declare the validation.
send(validation_method(options[:on] || :save), options) do |record|
attrs.each do |attr|
value = record.send(attr)
next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
yield record, attr, value
end
end
end
private
def validation_method(on)
case on
when :save then :validate
when :create then :validate_on_create
when :update then :validate_on_update
end
end
end
# Returns the Errors object that holds all information about attribute error messages.
def errors
@errors ||= Errors.new
end
# Runs all the specified validations and returns true if no errors were added otherwise false.
def valid?
errors.clear
run_callbacks(:validate)
if responds_to?(:validate)
ActiveSupport::Deprecations.warn "Base#validate has been deprecated, please use Base.validate :method instead"
validate
end
if new_record?
run_callbacks(:validate_on_create)
if responds_to?(:validate_on_create)
ActiveSupport::Deprecations.warn(
"Base#validate_on_create has been deprecated, please use Base.validate_on_create :method instead")
validate_on_create
end
else
run_callbacks(:validate_on_update)
if responds_to?(:validate_on_update)
ActiveSupport::Deprecations.warn(
"Base#validate_on_update has been deprecated, please use Base.validate_on_update :method instead")
validate_on_update
end
end
errors.empty?
end
end
end
Dir[File.dirname(__FILE__) + "/validations/*.rb"].sort.each do |path|
filename = File.basename(path)
require "active_model/validations/#{filename}"
end

45
vendor/rails/activemodel/lib/active_model/validations/acceptance.rb vendored Normal file
View file

@ -0,0 +1,45 @@
module ActiveModel
module Validations
module ClassMethods
# Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
#
# class Person < ActiveRecord::Base
# validates_acceptance_of :terms_of_service
# validates_acceptance_of :eula, :message => "must be abided"
# end
#
# If the database column does not exist, the <tt>:terms_of_service</tt> attribute is entirely virtual. This check is
# performed only if <tt>:terms_of_service</tt> is not +nil+ and by default on save.
#
# Configuration options:
# * <tt>:message</tt> - A custom error message (default is: "must be accepted")
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+. (default is +true+)
# * <tt>:accept</tt> - Specifies value that is considered accepted. The default value is a string "1", which
# makes it easy to relate to an HTML checkbox. This should be set to +true+ if you are validating a database
# column, since the attribute is typecasted from "1" to +true+ before validation.
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_acceptance_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true, :accept => "1" }
configuration.update(attr_names.extract_options!)
db_cols = begin
column_names
rescue ActiveRecord::StatementInvalid
[]
end
names = attr_names.reject { |name| db_cols.include?(name.to_s) }
attr_accessor(*names)
validates_each(attr_names,configuration) do |record, attr_name, value|
record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]
end
end
end
end
end

46
vendor/rails/activemodel/lib/active_model/validations/associated.rb vendored Normal file
View file

@ -0,0 +1,46 @@
module ActiveModel
module Validations
module ClassMethods
# Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
#
# class Book < ActiveRecord::Base
# has_many :pages
# belongs_to :library
#
# validates_associated :pages, :library
# end
#
# Warning: If, after the above definition, you then wrote:
#
# class Page < ActiveRecord::Base
# belongs_to :book
#
# validates_associated :book
# end
#
# ...this would specify a circular dependency and cause infinite recursion.
#
# NOTE: This validation will not fail if the association hasn't been assigned. If you want to ensure that the association
# is both present and guaranteed to be valid, you also need to use +validates_presence_of+.
#
# Configuration options:
# * <tt>:message</tt> - A custom error message (default is: "is invalid")
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_associated(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save }
configuration.update(attr_names.extract_options!)
validates_each(attr_names, configuration) do |record, attr_name, value|
record.errors.add(attr_name, configuration[:message]) unless
(value.is_a?(Array) ? value : [value]).inject(true) { |v, r| (r.nil? || r.valid?) && v }
end
end
end
end
end

44
vendor/rails/activemodel/lib/active_model/validations/confirmation.rb vendored Normal file
View file

@ -0,0 +1,44 @@
module ActiveModel
module Validations
module ClassMethods
# Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
#
# Model:
# class Person < ActiveRecord::Base
# validates_confirmation_of :user_name, :password
# validates_confirmation_of :email_address, :message => "should match confirmation"
# end
#
# View:
# <%= password_field "person", "password" %>
# <%= password_field "person", "password_confirmation" %>
#
# The added +password_confirmation+ attribute is virtual; it exists only as an in-memory attribute for validating the password.
# To achieve this, the validation adds accessors to the model for the confirmation attribute. NOTE: This check is performed
# only if +password_confirmation+ is not +nil+, and by default only on save. To require confirmation, make sure to add a presence
# check for the confirmation attribute:
#
# validates_presence_of :password_confirmation, :if => :password_changed?
#
# Configuration options:
# * <tt>:message</tt> - A custom error message (default is: "doesn't match confirmation")
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_confirmation_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:confirmation], :on => :save }
configuration.update(attr_names.extract_options!)
attr_accessor(*(attr_names.map { |n| "#{n}_confirmation" }))
validates_each(attr_names, configuration) do |record, attr_name, value|
record.errors.add(attr_name, configuration[:message]) unless record.send("#{attr_name}_confirmation").nil? or value == record.send("#{attr_name}_confirmation")
end
end
end
end
end

37
vendor/rails/activemodel/lib/active_model/validations/exclusion.rb vendored Normal file
View file

@ -0,0 +1,37 @@
module ActiveModel
module Validations
module ClassMethods
# Validates that the value of the specified attribute is not in a particular enumerable object.
#
# class Person < ActiveRecord::Base
# validates_exclusion_of :username, :in => %w( admin superuser ), :message => "You don't belong here"
# validates_exclusion_of :age, :in => 30..60, :message => "This site is only for under 30 and over 60"
# validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension %s is not allowed"
# end
#
# Configuration options:
# * <tt>:in</tt> - An enumerable object of items that the value shouldn't be part of
# * <tt>:message</tt> - Specifies a custom error message (default is: "is reserved")
# * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is +nil+ (default is: +false+)
# * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_exclusion_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:exclusion], :on => :save }
configuration.update(attr_names.extract_options!)
enum = configuration[:in] || configuration[:within]
raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?(:include?)
validates_each(attr_names, configuration) do |record, attr_name, value|
record.errors.add(attr_name, configuration[:message] % value) if enum.include?(value)
end
end
end
end
end

39
vendor/rails/activemodel/lib/active_model/validations/format.rb vendored Normal file
View file

@ -0,0 +1,39 @@
module ActiveModel
module Validations
module ClassMethods
# Validates whether the value of the specified attribute is of the correct form by matching it against the regular expression
# provided.
#
# class Person < ActiveRecord::Base
# validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :on => :create
# end
#
# Note: use <tt>\A</tt> and <tt>\Z</tt> to match the start and end of the string, <tt>^</tt> and <tt>$</tt> match the start/end of a line.
#
# A regular expression must be provided or else an exception will be raised.
#
# Configuration options:
# * <tt>:message</tt> - A custom error message (default is: "is invalid")
# * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is +nil+ (default is: +false+)
# * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
# * <tt>:with</tt> - The regular expression used to validate the format with (note: must be supplied!)
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_format_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save, :with => nil }
configuration.update(attr_names.extract_options!)
raise(ArgumentError, "A regular expression must be supplied as the :with option of the configuration hash") unless configuration[:with].is_a?(Regexp)
validates_each(attr_names, configuration) do |record, attr_name, value|
record.errors.add(attr_name, configuration[:message]) unless value.to_s =~ configuration[:with]
end
end
end
end
end

37
vendor/rails/activemodel/lib/active_model/validations/inclusion.rb vendored Normal file
View file

@ -0,0 +1,37 @@
module ActiveModel
module Validations
module ClassMethods
# Validates whether the value of the specified attribute is available in a particular enumerable object.
#
# class Person < ActiveRecord::Base
# validates_inclusion_of :gender, :in => %w( m f )
# validates_inclusion_of :age, :in => 0..99
# validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension %s is not included in the list"
# end
#
# Configuration options:
# * <tt>:in</tt> - An enumerable object of available items
# * <tt>:message</tt> - Specifies a custom error message (default is: "is not included in the list")
# * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is null (default is: +false+)
# * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_inclusion_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:inclusion], :on => :save }
configuration.update(attr_names.extract_options!)
enum = configuration[:in] || configuration[:within]
raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?(:include?)
validates_each(attr_names, configuration) do |record, attr_name, value|
record.errors.add(attr_name, configuration[:message] % value) unless enum.include?(value)
end
end
end
end
end

95
vendor/rails/activemodel/lib/active_model/validations/length.rb vendored Normal file
View file

@ -0,0 +1,95 @@
module ActiveModel
module Validations
module ClassMethods
ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
# Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:
#
# class Person < ActiveRecord::Base
# validates_length_of :first_name, :maximum => 30
# validates_length_of :last_name, :maximum => 30, :message => "less than %d if you don't mind"
# validates_length_of :fax, :in => 7..32, :allow_nil => true
# validates_length_of :phone, :in => 7..32, :allow_blank => true
# validates_length_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name"
# validates_length_of :fav_bra_size, :minimum => 1, :too_short => "please enter at least %d character"
# validates_length_of :smurf_leader, :is => 4, :message => "papa is spelled with %d characters... don't play me."
# end
#
# Configuration options:
# * <tt>:minimum</tt> - The minimum size of the attribute
# * <tt>:maximum</tt> - The maximum size of the attribute
# * <tt>:is</tt> - The exact size of the attribute
# * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute
# * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>
# * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
# * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
# * <tt>:too_long</tt> - The error message if the attribute goes over the maximum (default is: "is too long (maximum is %d characters)")
# * <tt>:too_short</tt> - The error message if the attribute goes under the minimum (default is: "is too short (min is %d characters)")
# * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt> method and the attribute is the wrong size (default is: "is the wrong length (should be %d characters)")
# * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>, <tt>:maximum</tt>, or <tt>:is</tt> violation. An alias of the appropriate <tt>:too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_length_of(*attrs)
# Merge given options with defaults.
options = {
:too_long => ActiveRecord::Errors.default_error_messages[:too_long],
:too_short => ActiveRecord::Errors.default_error_messages[:too_short],
:wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]
}.merge(DEFAULT_VALIDATION_OPTIONS)
options.update(attrs.extract_options!.symbolize_keys)
# Ensure that one and only one range option is specified.
range_options = ALL_RANGE_OPTIONS & options.keys
case range_options.size
when 0
raise ArgumentError, 'Range unspecified. Specify the :within, :maximum, :minimum, or :is option.'
when 1
# Valid number of options; do nothing.
else
raise ArgumentError, 'Too many range options specified. Choose only one.'
end
# Get range option and value.
option = range_options.first
option_value = options[range_options.first]
case option
when :within, :in
raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)
too_short = options[:too_short] % option_value.begin
too_long = options[:too_long] % option_value.end
validates_each(attrs, options) do |record, attr, value|
value = value.split(//) if value.kind_of?(String)
if value.nil? or value.size < option_value.begin
record.errors.add(attr, too_short)
elsif value.size > option_value.end
record.errors.add(attr, too_long)
end
end
when :is, :minimum, :maximum
raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0
# Declare different validations per option.
validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
message = (options[:message] || options[message_options[option]]) % option_value
validates_each(attrs, options) do |record, attr, value|
value = value.split(//) if value.kind_of?(String)
record.errors.add(attr, message) unless !value.nil? and value.size.method(validity_checks[option])[option_value]
end
end
end
alias_method :validates_size_of, :validates_length_of
end
end
end

80
vendor/rails/activemodel/lib/active_model/validations/numericality.rb vendored Normal file
View file

@ -0,0 +1,80 @@
module ActiveModel
module Validations
module ClassMethods
ALL_NUMERICALITY_CHECKS = { :greater_than => '>', :greater_than_or_equal_to => '>=',
:equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
:odd => 'odd?', :even => 'even?' }.freeze
# Validates whether the value of the specified attribute is numeric by trying to convert it to
# a float with Kernel.Float (if <tt>integer</tt> is false) or applying it to the regular expression
# <tt>/\A[\+\-]?\d+\Z/</tt> (if <tt>integer</tt> is true).
#
# class Person < ActiveRecord::Base
# validates_numericality_of :value, :on => :create
# end
#
# Configuration options:
# * <tt>:message</tt> - A custom error message (default is: "is not a number").
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
# * <tt>:only_integer</tt> - Specifies whether the value has to be an integer, e.g. an integral value (default is +false+).
# * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is +false+). Notice that for fixnum and float columns empty strings are converted to +nil+.
# * <tt>:greater_than</tt> - Specifies the value must be greater than the supplied value.
# * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be greater than or equal the supplied value.
# * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied value.
# * <tt>:less_than</tt> - Specifies the value must be less than the supplied value.
# * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less than or equal the supplied value.
# * <tt>:odd</tt> - Specifies the value must be an odd number.
# * <tt>:even</tt> - Specifies the value must be an even number.
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_numericality_of(*attr_names)
configuration = { :on => :save, :only_integer => false, :allow_nil => false }
configuration.update(attr_names.extract_options!)
numericality_options = ALL_NUMERICALITY_CHECKS.keys & configuration.keys
(numericality_options - [ :odd, :even ]).each do |option|
raise ArgumentError, ":#{option} must be a number" unless configuration[option].is_a?(Numeric)
end
validates_each(attr_names,configuration) do |record, attr_name, value|
raw_value = record.send("#{attr_name}_before_type_cast") || value
next if configuration[:allow_nil] and raw_value.nil?
if configuration[:only_integer]
unless raw_value.to_s =~ /\A[+-]?\d+\Z/
record.errors.add(attr_name, configuration[:message] || ActiveRecord::Errors.default_error_messages[:not_a_number])
next
end
raw_value = raw_value.to_i
else
begin
raw_value = Kernel.Float(raw_value.to_s)
rescue ArgumentError, TypeError
record.errors.add(attr_name, configuration[:message] || ActiveRecord::Errors.default_error_messages[:not_a_number])
next
end
end
numericality_options.each do |option|
case option
when :odd, :even
record.errors.add(attr_name, configuration[:message] || ActiveRecord::Errors.default_error_messages[option]) unless raw_value.to_i.method(ALL_NUMERICALITY_CHECKS[option])[]
else
message = configuration[:message] || ActiveRecord::Errors.default_error_messages[option]
message = message % configuration[option] if configuration[option]
record.errors.add(attr_name, message) unless raw_value.method(ALL_NUMERICALITY_CHECKS[option])[configuration[option]]
end
end
end
end
end
end
end

42
vendor/rails/activemodel/lib/active_model/validations/presence.rb vendored Normal file
View file

@ -0,0 +1,42 @@
module ActiveModel
module Validations
module ClassMethods
# Validates that the specified attributes are not blank (as defined by Object#blank?). Happens by default on save. Example:
#
# class Person < ActiveRecord::Base
# validates_presence_of :first_name
# end
#
# The +first_name+ attribute must be in the object and it cannot be blank.
#
# If you want to validate the presence of a boolean field (where the real values are +true+ and +false+),
# you will want to use
#
# validates_inclusion_of :field_name, :in => [true, false]
#
# This is due to the way Object#blank? handles boolean values:
#
# false.blank? # => true
#
# Configuration options:
# * <tt>:message</tt> - A custom error message (default is: "can't be blank")
# * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_presence_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:blank], :on => :save }
configuration.update(attr_names.extract_options!)
# can't use validates_each here, because it cannot cope with nonexistent attributes,
# while errors.add_on_empty can
send(validation_method(configuration[:on]), configuration) do |record|
record.errors.add_on_blank(attr_names, configuration[:message])
end
end
end
end
end

104
vendor/rails/activemodel/lib/active_model/validations/uniqueness.rb vendored Normal file
View file

@ -0,0 +1,104 @@
module ActiveModel
module Validations
module ClassMethods
# Validates whether the value of the specified attributes are unique across the system. Useful for making sure that only one user
# can be named "davidhh".
#
# class Person < ActiveRecord::Base
# validates_uniqueness_of :user_name, :scope => :account_id
# end
#
# It can also validate whether the value of the specified attributes are unique based on multiple scope parameters. For example,
# making sure that a teacher can only be on the schedule once per semester for a particular class.
#
# class TeacherSchedule < ActiveRecord::Base
# validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
# end
#
# When the record is created, a check is performed to make sure that no record exists in the database with the given value for the specified
# attribute (that maps to a column). When the record is updated, the same check is made but disregarding the record itself.
#
# Because this check is performed outside the database there is still a chance that duplicate values
# will be inserted in two parallel transactions. To guarantee against this you should create a
# unique index on the field. See +add_index+ for more information.
#
# Configuration options:
# * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken")
# * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
# * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by non-text columns (+true+ by default).
# * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is +nil+ (default is: +false+)
# * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
# occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
# not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
# method, proc or string should return or evaluate to a true or false value.
def validates_uniqueness_of(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken] }
configuration.update(attr_names.extract_options!)
validates_each(attr_names,configuration) do |record, attr_name, value|
# The check for an existing value should be run from a class that
# isn't abstract. This means working down from the current class
# (self), to the first non-abstract class. Since classes don't know
# their subclasses, we have to build the hierarchy between self and
# the record's class.
class_hierarchy = [record.class]
while class_hierarchy.first != self
class_hierarchy.insert(0, class_hierarchy.first.superclass)
end
# Now we can work our way down the tree to the first non-abstract
# class (which has a database table to query from).
finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
if value.nil? || (configuration[:case_sensitive] || !finder_class.columns_hash[attr_name.to_s].text?)
condition_sql = "#{record.class.quoted_table_name}.#{attr_name} #{attribute_condition(value)}"
condition_params = [value]
else
# sqlite has case sensitive SELECT query, while MySQL/Postgresql don't.
# Hence, this is needed only for sqlite.
condition_sql = "LOWER(#{record.class.quoted_table_name}.#{attr_name}) #{attribute_condition(value)}"
condition_params = [value.downcase]
end
if scope = configuration[:scope]
Array(scope).map do |scope_item|
scope_value = record.send(scope_item)
condition_sql << " AND #{record.class.quoted_table_name}.#{scope_item} #{attribute_condition(scope_value)}"
condition_params << scope_value
end
end
unless record.new_record?
condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
condition_params << record.send(:id)
end
results = finder_class.with_exclusive_scope do
connection.select_all(
construct_finder_sql(
:select => attr_name,
:from => finder_class.quoted_table_name,
:conditions => [condition_sql, *condition_params]
)
)
end
unless results.length.zero?
found = true
# As MySQL/Postgres don't have case sensitive SELECT queries, we try to find duplicate
# column in ruby when case sensitive option
if configuration[:case_sensitive] && finder_class.columns_hash[attr_name.to_s].text?
found = results.any? { |a| a[attr_name.to_s] == value }
end
record.errors.add(attr_name, configuration[:message]) if found
end
end
end
end
end
end

121
vendor/rails/activemodel/test/observing_test.rb vendored Normal file
View file

@ -0,0 +1,121 @@
require 'test_helper'
class ObservedModel < ActiveModel::Base
class Observer
end
end
class FooObserver < ActiveModel::Observer
class << self
public :new
end
attr_accessor :stub
def on_spec(record)
stub.event_with(record) if stub
end
end
class Foo < ActiveModel::Base
end
class ObservingTest < ActiveModel::TestCase
def setup
ObservedModel.observers.clear
end
test "initializes model with no cached observers" do
assert ObservedModel.observers.empty?, "Not empty: #{ObservedModel.observers.inspect}"
end
test "stores cached observers in an array" do
ObservedModel.observers << :foo
assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}"
end
test "flattens array of assigned cached observers" do
ObservedModel.observers = [[:foo], :bar]
assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}"
assert ObservedModel.observers.include?(:bar), ":bar not in #{ObservedModel.observers.inspect}"
end
test "instantiates observer names passed as strings" do
ObservedModel.observers << 'foo_observer'
FooObserver.expects(:instance)
ObservedModel.instantiate_observers
end
test "instantiates observer names passed as symbols" do
ObservedModel.observers << :foo_observer
FooObserver.expects(:instance)
ObservedModel.instantiate_observers
end
test "instantiates observer classes" do
ObservedModel.observers << ObservedModel::Observer
ObservedModel::Observer.expects(:instance)
ObservedModel.instantiate_observers
end
test "passes observers to subclasses" do
FooObserver.instance
bar = Class.new(Foo)
assert_equal Foo.count_observers, bar.count_observers
end
end
class ObserverTest < ActiveModel::TestCase
def setup
ObservedModel.observers = :foo_observer
FooObserver.models = nil
end
test "guesses implicit observable model name" do
assert_equal 'Foo', FooObserver.observed_class_name
end
test "tracks implicit observable models" do
instance = FooObserver.new
assert instance.send(:observed_classes).include?(Foo), "Foo not in #{instance.send(:observed_classes).inspect}"
assert !instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{instance.send(:observed_classes).inspect}"
end
test "tracks explicit observed model class" do
old_instance = FooObserver.new
assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}"
FooObserver.observe ObservedModel
instance = FooObserver.new
assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}"
end
test "tracks explicit observed model as string" do
old_instance = FooObserver.new
assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}"
FooObserver.observe 'observed_model'
instance = FooObserver.new
assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}"
end
test "tracks explicit observed model as symbol" do
old_instance = FooObserver.new
assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}"
FooObserver.observe :observed_model
instance = FooObserver.new
assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}"
end
test "calls existing observer event" do
foo = Foo.new
FooObserver.instance.stub = stub
FooObserver.instance.stub.expects(:event_with).with(foo)
Foo.send(:changed)
Foo.send(:notify_observers, :on_spec, foo)
end
test "skips nonexistent observer event" do
foo = Foo.new
Foo.send(:changed)
Foo.send(:notify_observers, :whatever, foo)
end
end

49
vendor/rails/activemodel/test/state_machine/event_test.rb vendored Normal file
View file

@ -0,0 +1,49 @@
require 'test_helper'
class EventTest < ActiveModel::TestCase
def setup
@state_name = :close_order
@success = :success_callback
end
def new_event
@event = ActiveModel::StateMachine::Event.new(nil, @state_name, {:success => @success}) do
transitions :to => :closed, :from => [:open, :received]
end
end
test 'should set the name' do
assert_equal @state_name, new_event.name
end
test 'should set the success option' do
assert_equal @success, new_event.success
end
test 'should create StateTransitions' do
ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :open)
ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :received)
new_event
end
end
class EventBeingFiredTest < ActiveModel::TestCase
test 'should raise an AASM::InvalidTransition error if the transitions are empty' do
event = ActiveModel::StateMachine::Event.new(nil, :event)
assert_raise ActiveModel::StateMachine::InvalidTransition do
event.fire(nil)
end
end
test 'should return the state of the first matching transition it finds' do
event = ActiveModel::StateMachine::Event.new(nil, :event) do
transitions :to => :closed, :from => [:open, :received]
end
obj = stub
obj.stubs(:current_state).returns(:open)
assert_equal :closed, event.fire(obj)
end
end

43
vendor/rails/activemodel/test/state_machine/machine_test.rb vendored Normal file
View file

@ -0,0 +1,43 @@
require 'test_helper'
class MachineTestSubject
include ActiveModel::StateMachine
state_machine do
state :open
state :closed
end
state_machine :initial => :foo do
event :shutdown do
transitions :from => :open, :to => :closed
end
event :timeout do
transitions :from => :open, :to => :closed
end
end
state_machine :extra, :initial => :bar do
end
end
class StateMachineMachineTest < ActiveModel::TestCase
test "allows reuse of existing machines" do
assert_equal 2, MachineTestSubject.state_machines.size
end
test "sets #initial_state from :initial option" do
assert_equal :bar, MachineTestSubject.state_machine(:extra).initial_state
end
test "accesses non-default state machine" do
assert_kind_of ActiveModel::StateMachine::Machine, MachineTestSubject.state_machine(:extra)
end
test "finds events for given state" do
events = MachineTestSubject.state_machine.events_for(:open)
assert events.include?(:shutdown)
assert events.include?(:timeout)
end
end

72
vendor/rails/activemodel/test/state_machine/state_test.rb vendored Normal file
View file

@ -0,0 +1,72 @@
require 'test_helper'
class StateTestSubject
include ActiveModel::StateMachine
state_machine do
end
end
class StateTest < ActiveModel::TestCase
def setup
@state_name = :astate
@machine = StateTestSubject.state_machine
@options = { :crazy_custom_key => 'key', :machine => @machine }
end
def new_state(options={})
ActiveModel::StateMachine::State.new(@state_name, @options.merge(options))
end
test 'sets the name' do
assert_equal :astate, new_state.name
end
test 'sets the display_name from name' do
assert_equal "Astate", new_state.display_name
end
test 'sets the display_name from options' do
assert_equal "A State", new_state(:display => "A State").display_name
end
test 'sets the options and expose them as options' do
@options.delete(:machine)
assert_equal @options, new_state.options
end
test 'equals a symbol of the same name' do
assert_equal new_state, :astate
end
test 'equals a State of the same name' do
assert_equal new_state, new_state
end
test 'should send a message to the record for an action if the action is present as a symbol' do
state = new_state(:entering => :foo)
record = stub
record.expects(:foo)
state.call_action(:entering, record)
end
test 'should send a message to the record for an action if the action is present as a string' do
state = new_state(:entering => 'foo')
record = stub
record.expects(:foo)
state.call_action(:entering, record)
end
test 'should call a proc, passing in the record for an action if the action is present' do
state = new_state(:entering => Proc.new {|r| r.foobar})
record = stub
record.expects(:foobar)
state.call_action(:entering, record)
end
end

84
vendor/rails/activemodel/test/state_machine/state_transition_test.rb vendored Normal file
View file

@ -0,0 +1,84 @@
require 'test_helper'
class StateTransitionTest < ActiveModel::TestCase
test 'should set from, to, and opts attr readers' do
opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
st = ActiveModel::StateMachine::StateTransition.new(opts)
assert_equal opts[:from], st.from
assert_equal opts[:to], st.to
assert_equal opts, st.options
end
test 'should pass equality check if from and to are the same' do
opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
st = ActiveModel::StateMachine::StateTransition.new(opts)
obj = stub
obj.stubs(:from).returns(opts[:from])
obj.stubs(:to).returns(opts[:to])
assert_equal st, obj
end
test 'should fail equality check if from are not the same' do
opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
st = ActiveModel::StateMachine::StateTransition.new(opts)
obj = stub
obj.stubs(:from).returns('blah')
obj.stubs(:to).returns(opts[:to])
assert_not_equal st, obj
end
test 'should fail equality check if to are not the same' do
opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
st = ActiveModel::StateMachine::StateTransition.new(opts)
obj = stub
obj.stubs(:from).returns(opts[:from])
obj.stubs(:to).returns('blah')
assert_not_equal st, obj
end
end
class StateTransitionGuardCheckTest < ActiveModel::TestCase
test 'should return true of there is no guard' do
opts = {:from => 'foo', :to => 'bar'}
st = ActiveModel::StateMachine::StateTransition.new(opts)
assert st.perform(nil)
end
test 'should call the method on the object if guard is a symbol' do
opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
st = ActiveModel::StateMachine::StateTransition.new(opts)
obj = stub
obj.expects(:test_guard)
st.perform(obj)
end
test 'should call the method on the object if guard is a string' do
opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
st = ActiveModel::StateMachine::StateTransition.new(opts)
obj = stub
obj.expects(:test_guard)
st.perform(obj)
end
test 'should call the proc passing the object if the guard is a proc' do
opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
st = ActiveModel::StateMachine::StateTransition.new(opts)
obj = stub
obj.expects(:test_guard)
st.perform(obj)
end
end

312
vendor/rails/activemodel/test/state_machine_test.rb vendored Normal file
View file

@ -0,0 +1,312 @@
require 'test_helper'
class StateMachineSubject
include ActiveModel::StateMachine
state_machine do
state :open, :exit => :exit
state :closed, :enter => :enter
event :close, :success => :success_callback do
transitions :to => :closed, :from => [:open]
end
event :null do
transitions :to => :closed, :from => [:open], :guard => :always_false
end
end
state_machine :bar do
state :read
state :ended
event :foo do
transitions :to => :ended, :from => [:read]
end
end
def always_false
false
end
def success_callback
end
def enter
end
def exit
end
end
class StateMachineSubjectSubclass < StateMachineSubject
end
class StateMachineClassLevelTest < ActiveModel::TestCase
test 'defines a class level #state_machine method on its including class' do
assert StateMachineSubject.respond_to?(:state_machine)
end
test 'defines a class level #state_machines method on its including class' do
assert StateMachineSubject.respond_to?(:state_machines)
end
test 'class level #state_machine returns machine instance' do
assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machine
end
test 'class level #state_machine returns machine instance with given name' do
assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machine(:default)
end
test 'class level #state_machines returns hash of machine instances' do
assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machines[:default]
end
test "should return a select friendly array of states in the form of [['Friendly name', 'state_name']]" do
assert_equal [['Open', 'open'], ['Closed', 'closed']], StateMachineSubject.state_machine.states_for_select
end
end
class StateMachineInstanceLevelTest < ActiveModel::TestCase
def setup
@foo = StateMachineSubject.new
end
test 'defines an accessor for the current state' do
assert @foo.respond_to?(:current_state)
end
test 'defines a state querying instance method on including class' do
assert @foo.respond_to?(:open?)
end
test 'defines an event! instance method' do
assert @foo.respond_to?(:close!)
end
test 'defines an event instance method' do
assert @foo.respond_to?(:close)
end
end
class StateMachineInitialStatesTest < ActiveModel::TestCase
def setup
@foo = StateMachineSubject.new
end
test 'sets the initial state' do
assert_equal :open, @foo.current_state
end
test '#open? should be initially true' do
assert @foo.open?
end
test '#closed? should be initially false' do
assert !@foo.closed?
end
test 'uses the first state defined if no initial state is given' do
assert_equal :read, @foo.current_state(:bar)
end
end
class StateMachineEventFiringWithPersistenceTest < ActiveModel::TestCase
def setup
@subj = StateMachineSubject.new
end
test 'updates the current state' do
@subj.close!
assert_equal :closed, @subj.current_state
end
test 'fires the Event' do
@subj.class.state_machine.events[:close].expects(:fire).with(@subj)
@subj.close!
end
test 'calls the success callback if one was provided' do
@subj.expects(:success_callback)
@subj.close!
end
test 'attempts to persist if write_state is defined' do
def @subj.write_state
end
@subj.expects(:write_state)
@subj.close!
end
end
class StateMachineEventFiringWithoutPersistence < ActiveModel::TestCase
test 'updates the current state' do
subj = StateMachineSubject.new
assert_equal :open, subj.current_state
subj.close
assert_equal :closed, subj.current_state
end
test 'fires the Event' do
subj = StateMachineSubject.new
StateMachineSubject.state_machine.events[:close].expects(:fire).with(subj)
subj.close
end
test 'attempts to persist if write_state is defined' do
subj = StateMachineSubject.new
def subj.write_state
end
subj.expects(:write_state_without_persistence)
subj.close
end
end
class StateMachinePersistenceTest < ActiveModel::TestCase
test 'reads the state if it has not been set and read_state is defined' do
subj = StateMachineSubject.new
def subj.read_state
end
subj.expects(:read_state).with(StateMachineSubject.state_machine)
subj.current_state
end
end
class StateMachineEventCallbacksTest < ActiveModel::TestCase
test 'should call aasm_event_fired if defined and successful for bang fire' do
subj = StateMachineSubject.new
def subj.aasm_event_fired(from, to)
end
subj.expects(:event_fired)
subj.close!
end
test 'should call aasm_event_fired if defined and successful for non-bang fire' do
subj = StateMachineSubject.new
def subj.aasm_event_fired(from, to)
end
subj.expects(:event_fired)
subj.close
end
test 'should call aasm_event_failed if defined and transition failed for bang fire' do
subj = StateMachineSubject.new
def subj.event_failed(event)
end
subj.expects(:event_failed)
subj.null!
end
test 'should call aasm_event_failed if defined and transition failed for non-bang fire' do
subj = StateMachineSubject.new
def subj.aasm_event_failed(event)
end
subj.expects(:event_failed)
subj.null
end
end
class StateMachineStateActionsTest < ActiveModel::TestCase
test "calls enter when entering state" do
subj = StateMachineSubject.new
subj.expects(:enter)
subj.close
end
test "calls exit when exiting state" do
subj = StateMachineSubject.new
subj.expects(:exit)
subj.close
end
end
class StateMachineInheritanceTest < ActiveModel::TestCase
test "has the same states as its parent" do
assert_equal StateMachineSubject.state_machine.states, StateMachineSubjectSubclass.state_machine.states
end
test "has the same events as its parent" do
assert_equal StateMachineSubject.state_machine.events, StateMachineSubjectSubclass.state_machine.events
end
end
class StateMachineSubject
state_machine :chetan_patil, :initial => :sleeping do
state :sleeping
state :showering
state :working
state :dating
event :wakeup do
transitions :from => :sleeping, :to => [:showering, :working]
end
event :dress do
transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
end
end
def wear_clothes(shirt_color, trouser_type)
end
end
class StateMachineWithComplexTransitionsTest < ActiveModel::TestCase
def setup
@subj = StateMachineSubject.new
end
test 'transitions to specified next state (sleeping to showering)' do
@subj.wakeup! :showering
assert_equal :showering, @subj.current_state(:chetan_patil)
end
test 'transitions to specified next state (sleeping to working)' do
@subj.wakeup! :working
assert_equal :working, @subj.current_state(:chetan_patil)
end
test 'transitions to default (first or showering) state' do
@subj.wakeup!
assert_equal :showering, @subj.current_state(:chetan_patil)
end
test 'transitions to default state when on_transition invoked' do
@subj.dress!(nil, 'purple', 'dressy')
assert_equal :working, @subj.current_state(:chetan_patil)
end
test 'calls on_transition method with args' do
@subj.wakeup! :showering
@subj.expects(:wear_clothes).with('blue', 'jeans')
@subj.dress! :working, 'blue', 'jeans'
end
test 'calls on_transition proc' do
@subj.wakeup! :showering
@subj.expects(:wear_clothes).with('purple', 'slacks')
@subj.dress!(:dating, 'purple', 'slacks')
end
end

21
vendor/rails/activemodel/test/test_helper.rb vendored Normal file
View file

@ -0,0 +1,21 @@
require 'rubygems'
require 'test/unit'
gem 'mocha', '>= 0.9.3'
require 'mocha'
require 'active_model'
require 'active_model/state_machine'
$:.unshift File.expand_path('../../../activesupport/lib', __FILE__)
require 'active_support'
require 'active_support/test_case'
class ActiveModel::TestCase < ActiveSupport::TestCase
end
begin
require 'ruby-debug'
Debugger.start
rescue LoadError
end