-## Rails 4.0.0 (unreleased) ##

-* Add `ActiveModel::ForbiddenAttributesProtection`, a simple module to

- protect attributes from mass assignment when non-permitted attributes are passed.

- *DHH + Guillermo Iguaran*

-* `ActiveModel::MassAssignmentSecurity` has been extracted from Active Model and the

- `protected_attributes` gem should be added to Gemfile in order to use

- `attr_accessible` and `attr_protected` macros in your models.

- *Guillermo Iguaran*

-

-* Due to a change in builder, nil values and empty strings now generates

- closed tags, so instead of this:

-

- <pseudonyms nil=\"true\"></pseudonyms>

-

- It generates this:

-

- <pseudonyms nil=\"true\"/>

-

- *Carlos Antonio da Silva*

-

-* Changed inclusion and exclusion validators to accept a symbol for `:in` option.

-

- This allows to use dynamic inclusion/exclusion values using methods, besides the current lambda/proc support.

-

- *Gabriel Sobrinho*

-

-* `AM::Validation#validates` ability to pass custom exception to `:strict` option.

-* Changed `ActiveModel::Serializers::Xml::Serializer#add_associations` to by default

- propagate `:skip_types, :dasherize, :camelize` keys to included associations.

- It can be overriden on each association by explicitly specifying the option on one

- or more associations

-

- *Anthony Alberto*

-

-* Changed `AM::Serializers::JSON.include_root_in_json' default value to false.

- Now, AM Serializers and AR objects have the same default behaviour. Fixes #6578.

-

- class User < ActiveRecord::Base; end

-

- class Person

- include ActiveModel::Model

- include ActiveModel::AttributeMethods

- include ActiveModel::Serializers::JSON

-

- attr_accessor :name, :age

-

- def attributes

- instance_values

- end

- end

-

- user.as_json

- => {"id"=>1, "name"=>"Konata Izumi", "age"=>16, "awesome"=>true}

- # root is not included

- person.as_json

- => {"name"=>"Francesco", "age"=>22}

- # root is not included

- *Francesco Rodriguez*

-* Passing false hash values to `validates` will no longer enable the corresponding validators *Steve Purcell*

-* `ConfirmationValidator` error messages will attach to `:#{attribute}_confirmation` instead of `attribute` *Brian Cardarella*

-* Added ActiveModel::Model, a mixin to make Ruby objects work with AP out of box *Guillermo Iguaran*

-* `AM::Errors#to_json`: support `:full_messages` parameter *Bogdan Gusiev*

-* Trim down Active Model API by removing `valid?` and `errors.full_messages` *José Valim*

-* When `^` or `$` are used in the regular expression provided to `validates_format_of` and the :multiline option is not set to true, an exception will be raised. This is to prevent security vulnerabilities when using `validates_format_of`. The problem is described in detail in the Rails security guide.

-Please check [3-2-stable](https://github.com/rails/rails/blob/3-2-stable/activemodel/CHANGELOG.md) for previous changes.

-Copyright (c) 2004-2012 David Heinemeier Hansson

-They allow for Action Pack helpers to interact with non-ActiveRecord models,

-for example. Active Model also helps building custom ORMs for use outside of

-API in ActiveModel::Lint::Tests.

- person.name # => 'bob'

- person.age # => '18'

- The ActiveModel::Dirty module allows for tracking attribute changes:

- person.name # => nil

- person.changed? # => false

- person.changed? # => true

- person.changed # => ['name']

- person.changes # => { 'name' => [nil, 'bob'] }

-* Observer support

- ActiveModel::Observers allows your object to implement the Observer

- pattern in a Rails App and take advantage of all the standard observer

- functions.

- class PersonObserver < ActiveModel::Observer

- def after_create(person)

- person.logger.info("New person added!")

- end

- def after_destroy(person)

- person.logger.warn("Person with an id of #{person.id} was destroyed!")

- {Learn more}[link:classes/ActiveModel/Observer.html]

-

-* Making objects serializable

- ActiveModel::Serialization provides a standard interface for your object

- to provide +to_json+ or +to_xml+ serialization.

- s.serializable_hash # => {"name"=>nil}

- ruby = File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME'))

- sh(ruby, '-w', "-I#{dir}/lib", "-I#{dir}/test", file)

-require 'rake/packagetask'

-desc "Release to gemcutter"

- s.description = 'A toolkit for building modeling frameworks like Active Record. Rich support for attributes, callbacks, validations, observers, serialization, internationalization, and testing.'

- s.license = 'MIT'

- s.author = 'David Heinemeier Hansson'

- s.email = 'david@loudthinking.com'

- s.homepage = 'http://www.rubyonrails.org'

- s.add_dependency('activesupport', version)

- s.add_dependency('builder', '~> 3.1.0')

- validates_presence_of :name

-p person1.valid?

-person1.errors

-person2 = Person.new(:name => "matz")

-p person2.valid?

-# Copyright (c) 2004-2012 David Heinemeier Hansson

- autoload :DeprecatedMassAssignmentSecurity

- autoload :Observer, 'active_model/observing'

- autoload :Observing

- # # => ActiveModel::MissingAttributeError: missing attribute: user_id

- # == Active Model Attribute Methods

- # suffixes to your methods as well as handling the creation of Active Record

- # like class methods such as +table_name+.

- # The requirements to implement ActiveModel::AttributeMethods are to:

- # * <tt>include ActiveModel::AttributeMethods</tt> in your object.

- # * Call each Attribute Method module method you want to add, such as

- # +attribute_method_suffix+ or +attribute_method_prefix+.

- # Note that whenever you include ActiveModel::AttributeMethods in your class,

- # it requires you to implement an +attributes+ method which returns a hash

- # with each attribute name in your model as hash key and the attribute value as

- # hash value.

-

- # person.nickname_short? # => true

- # Returns true if the attribute methods defined have been generated.

- @generated_attribute_methods ||= Module.new.tap { |mod| include mod }

- @attribute_method_matchers_cache ||= {}

- attribute_method_matchers_cache.fetch(method_name) do |name|

- matchers.detect { |method| match = method.match(name) }

- attribute_method_matchers_cache[name] = match

- if options[:prefix] == '' || options[:suffix] == ''

- ActiveSupport::Deprecation.warn(

- "Specifying an empty prefix/suffix for an attribute method is no longer " \

- "necessary. If the un-prefixed/suffixed version of the method has not been " \

- "defined when `define_attribute_methods` is called, it will be defined " \

- "automatically."

- )

- end

-

- # Allows access to the object attributes, which are held in the

- # <tt>@attributes</tt> hash, as though they were first-class methods. So a

- # Person class with a name attribute can use Person#name and Person#name=

- # and never directly use the attributes hash -- except for multiple assigns

- # with ActiveRecord#attributes=. A Milestone class can also ask

- # Milestone#completed? to test that the completed attribute is not +nil+

- # or 0.

- # It's also possible to instantiate related objects, so a Client class

- # belonging to the clients table with a +master_id+ foreign key can

- # instantiate master through Client#master.

- # attribute_missing is like method_missing, but for attributes. When method_missing is

- # called we check to see if there is a matching attribute method. If so, we call

- # attribute_missing to dispatch the attribute. This method can be overloaded to

- # customise the behaviour.

- # A Person object with a name attribute can ask <tt>person.respond_to?(:name)</tt>,

- # <tt>person.respond_to?(:name=)</tt>, and <tt>person.respond_to?(:name?)</tt>

- # which will all return +true+.

-require 'active_support/callbacks'

- # == Active Model Callbacks

- :terminator => "result == false",

- :skip_after_callbacks_if_terminated => true,

- :scope => [:kind, :name],

- :only => [:before, :around, :after]

- klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1

- def self.before_#{callback}(*args, &block)

- set_callback(:#{callback}, :before, *args, &block)

- end

- CALLBACK

- klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1

- def self.around_#{callback}(*args, &block)

- set_callback(:#{callback}, :around, *args, &block)

- end

- CALLBACK

- klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1

- def self.after_#{callback}(*args, &block)

- options = args.extract_options!

- options[:prepend] = true

- options[:if] = Array(options[:if]) << "value != false"

- set_callback(:#{callback}, :after, *(args << options), &block)

- end

- CALLBACK

-require 'active_support/inflector'

-

- # == Active Model Conversions

-module ActiveModel

- module DeprecatedMassAssignmentSecurity # :nodoc:

- extend ActiveSupport::Concern

-

- module ClassMethods # :nodoc:

- def attr_protected(*args)

- raise "`attr_protected` is extracted out of Rails into a gem. " \

- "Please use new recommended protection model for params " \

- "or add `protected_attributes` to your Gemfile to use old one."

- end

-

- def attr_accessible(*args)

- raise "`attr_accessible` is extracted out of Rails into a gem. " \

- "Please use new recommended protection model for params " \

- "or add `protected_attributes` to your Gemfile to use old one."

- end

- end

- end

-end

-require 'active_model/attribute_methods'

- # == Active Model Dirty

- #

- # If you wish to also track previous changes on save or update, you need to

- # add:

- #

- # @previously_changed = changes

- #

- # inside of your save or update method.

- # @previously_changed = changes

- # @changed_attributes.clear

- # person = Person.find_by_name('Uncle Bob')

- attribute_method_affix :prefix => 'reset_', :suffix => '!'

- HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]

- @previously_changed

- @changed_attributes ||= {}

- # Handle <tt>*_changed?</tt> for +method_missing+.

- def attribute_changed?(attr)

- changed_attributes.include?(attr)

- # Handle <tt>*_was</tt> for +method_missing+.

- def attribute_was(attr)

- attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)

- end

-

- __send__("#{attr}=", changed_attributes[attr]) if attribute_changed?(attr)

- # == Active Model Errors

- #

- #

- # p = Person.new

- def initialize_dup(other) #:nodoc:

- # person.errors.full_messages # => ["name can not be nil"]

- # person.errors.messages # => { :name => ["can not be nil"] }

- # person.errors.include?(:age) # => false

- # person.errors.messages # => { :name => ["can not be nil"] }

- # person.errors.delete(:name) # => ["can not be nil"]

- # person.errors.messages # => { :name => ["can not be nil", "must be specified"] }

- # person.errors.messages # => { :name => ["can not be nil", "must be specified"] }

- # person.errors.full_messages # => ["name can not be nil"]

- to_a.to_xml({ :root => "errors", :skip_types => true }.merge!(options))

- # person.as_json # => { :name => ["can not be nil"] }

- # person.as_json(full_messages: true) # => { :name => ["name can not be nil"] }

- # Returns a Hash of attributes with their error messages. If +full_messages+

- # person.to_hash # => { :name => ["can not be nil"] }

- # person.to_hash(true) # => { :name => ["name can not be nil"] }

- # # => { :name => ["must be implemented", "is invalid"] }

- # # => ActiveModel::StrictValidationFailed: name is invalid

- # # => NameIsInvalid: name is invalid

- def add(attribute, message = nil, options = {})

- # # => { :name => ["can't be empty"] }

- [attributes].flatten.each do |attribute|

- # # => { :name => ["can't be blank"] }

- [attributes].flatten.each do |attribute|

- def added?(attribute, message = nil, options = {})

- attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)

- :default => "%{attribute} %{message}",

- :attribute => attr_name,

- :message => message

- :default => defaults,

- :model => @base.class.model_name.human,

- :attribute => @base.class.human_attribute_name(attribute),

- :value => value

- message ||= :invalid

-

- def sanitize_for_mass_assignment(attributes, options = {})

- # == Active Model Lint Tests

- # You can test whether an object is compliant with the Active Model API by

- # == Naming

- # == Errors Testing

- assert @model.respond_to?(:to_model), "The object should respond_to to_model"

- # == Active Model Basic Model

-require 'active_support/inflector'

- # BlogPost.model_name <=> 'Blog' # => 1

- # BlogPost.model_name <=> 'BlogPosts' # => -1

- :to_str, :to => :name

- options = { :scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults }.merge!(options.except(:default))

- # == Active Model Naming

-require 'set'

-

-module ActiveModel

- # Stores the enabled/disabled state of individual observers for

- # a particular model class.

- class ObserverArray < Array

- attr_reader :model_class

- def initialize(model_class, *args) #:nodoc:

- @model_class = model_class

- super(*args)

- end

-

- # Returns +true+ if the given observer is disabled for the model class,

- # +false+ otherwise.

- def disabled_for?(observer) #:nodoc:

- disabled_observers.include?(observer.class)

- end

-

- # Disables one or more observers. This supports multiple forms:

- #

- # ORM.observers.disable :all

- # # => disables all observers for all models subclassed from

- # # an ORM base class that includes ActiveModel::Observing

- # # e.g. ActiveRecord::Base

- #

- # ORM.observers.disable :user_observer

- # # => disables the UserObserver

- #

- # User.observers.disable AuditTrail

- # # => disables the AuditTrail observer for User notifications.

- # # Other models will still notify the AuditTrail observer.

- #

- # ORM.observers.disable :observer_1, :observer_2

- # # => disables Observer1 and Observer2 for all models.

- #

- # User.observers.disable :all do

- # # all user observers are disabled for

- # # just the duration of the block

- # end

- def disable(*observers, &block)

- set_enablement(false, observers, &block)

- end

-

- # Enables one or more observers. This supports multiple forms:

- #

- # ORM.observers.enable :all

- # # => enables all observers for all models subclassed from

- # # an ORM base class that includes ActiveModel::Observing

- # # e.g. ActiveRecord::Base

- #

- # ORM.observers.enable :user_observer

- # # => enables the UserObserver

- #

- # User.observers.enable AuditTrail

- # # => enables the AuditTrail observer for User notifications.

- # # Other models will not be affected (i.e. they will not

- # # trigger notifications to AuditTrail if previously disabled)

- #

- # ORM.observers.enable :observer_1, :observer_2

- # # => enables Observer1 and Observer2 for all models.

- #

- # User.observers.enable :all do

- # # all user observers are enabled for

- # # just the duration of the block

- # end

- #

- # Note: all observers are enabled by default. This method is only

- # useful when you have previously disabled one or more observers.

- def enable(*observers, &block)

- set_enablement(true, observers, &block)

- end

-

- protected

-

- def disabled_observers #:nodoc:

- @disabled_observers ||= Set.new

- end

-

- def observer_class_for(observer) #:nodoc:

- return observer if observer.is_a?(Class)

-

- if observer.respond_to?(:to_sym) # string/symbol

- observer.to_s.camelize.constantize

- else

- raise ArgumentError, "#{observer} was not a class or a " +

- "lowercase, underscored class name as expected."

- end

- end

-

- def start_transaction #:nodoc:

- disabled_observer_stack.push(disabled_observers.dup)

- each_subclass_array do |array|

- array.start_transaction

- end

- end

-

- def disabled_observer_stack #:nodoc:

- @disabled_observer_stack ||= []

- end

-

- def end_transaction #:nodoc:

- @disabled_observers = disabled_observer_stack.pop

- each_subclass_array do |array|

- array.end_transaction

- end

- end

-

- def transaction #:nodoc:

- start_transaction

-

- begin

- yield

- ensure

- end_transaction

- end

- end

-

- def each_subclass_array #:nodoc:

- model_class.descendants.each do |subclass|

- yield subclass.observers

- end

- end

-

- def set_enablement(enabled, observers) #:nodoc:

- if block_given?

- transaction do

- set_enablement(enabled, observers)

- yield

- end

- else

- observers = ActiveModel::Observer.descendants if observers == [:all]

- observers.each do |obs|

- klass = observer_class_for(obs)

-

- unless klass < ActiveModel::Observer

- raise ArgumentError.new("#{obs} does not refer to a valid observer")

- end

-

- if enabled

- disabled_observers.delete(klass)

- else

- disabled_observers << klass

- end

- end

-

- each_subclass_array do |array|

- array.set_enablement(enabled, observers)

- end

- end

- end

- end

-end

-require 'singleton'

-require 'active_model/observer_array'

-require 'active_support/core_ext/module/aliasing'

-require 'active_support/core_ext/module/remove_method'

-require 'active_support/core_ext/string/inflections'

-require 'active_support/core_ext/enumerable'

-require 'active_support/core_ext/object/try'

-require 'active_support/descendants_tracker'

-

-module ActiveModel

- # == Active Model Observers Activation

- module Observing

- extend ActiveSupport::Concern

-

- included do

- extend ActiveSupport::DescendantsTracker

- end

-

- module ClassMethods

- # Activates the observers assigned.

- #

- # class ORM

- # include ActiveModel::Observing

- # end

- #

- # # Calls PersonObserver.instance

- # ORM.observers = :person_observer

- #

- # # Calls Cacher.instance and GarbageCollector.instance

- # ORM.observers = :cacher, :garbage_collector

- #

- # # Same as above, just using explicit class references

- # ORM.observers = Cacher, GarbageCollector

- #

- # Note: Setting this does not instantiate the observers yet.

- # <tt>instantiate_observers</tt> is called during startup, and before

- # each development request.

- def observers=(*values)

- observers.replace(values.flatten)

- end

-

- # Gets an array of observers observing this model. The array also provides

- # +enable+ and +disable+ methods that allow you to selectively enable and

- # disable observers (see ActiveModel::ObserverArray.enable and

- # ActiveModel::ObserverArray.disable for more on this).

- #

- # class ORM

- # include ActiveModel::Observing

- # end

- #

- # ORM.observers = :cacher, :garbage_collector

- # ORM.observers # => [:cacher, :garbage_collector]

- # ORM.observers.class # => ActiveModel::ObserverArray

- def observers

- @observers ||= ObserverArray.new(self)

- end

-

- # Returns the current observer instances.

- #

- # class Foo

- # include ActiveModel::Observing

- #

- # attr_accessor :status

- # end

- #

- # class FooObserver < ActiveModel::Observer

- # def on_spec(record, *args)

- # record.status = true

- # end

- # end

- #

- # Foo.observers = FooObserver

- # Foo.instantiate_observers

- #

- # Foo.observer_instances # => [#<FooObserver:0x007fc212c40820>]

- def observer_instances

- @observer_instances ||= []

- end

-

- # Instantiate the global observers.

- #

- # class Foo

- # include ActiveModel::Observing

- #

- # attr_accessor :status

- # end

- #

- # class FooObserver < ActiveModel::Observer

- # def on_spec(record, *args)

- # record.status = true

- # end

- # end

- #

- # Foo.observers = FooObserver

- #

- # foo = Foo.new

- # foo.status = false

- # foo.notify_observers(:on_spec)

- # foo.status # => false

- #

- # Foo.instantiate_observers # => [FooObserver]

- #

- # foo = Foo.new

- # foo.status = false

- # foo.notify_observers(:on_spec)

- # foo.status # => true

- def instantiate_observers

- observers.each { |o| instantiate_observer(o) }

- end

-

- # Add a new observer to the pool. The new observer needs to respond to

- # <tt>update</tt>, otherwise it raises an +ArgumentError+ exception.

- #

- # class Foo

- # include ActiveModel::Observing

- # end

- #

- # class FooObserver < ActiveModel::Observer

- # end

- #

- # Foo.add_observer(FooObserver.instance)

- #

- # Foo.observers_instance

- # # => [#<FooObserver:0x007fccf55d9390>]

- def add_observer(observer)

- unless observer.respond_to? :update

- raise ArgumentError, "observer needs to respond to 'update'"

- end

- observer_instances << observer

- end

-

- # Fires notifications to model's observers.

- #

- # def save

- # notify_observers(:before_save)

- # ...

- # notify_observers(:after_save)

- # end

- #

- # Custom notifications can be sent in a similar fashion:

- #

- # notify_observers(:custom_notification, :foo)

- #

- # This will call <tt>custom_notification</tt>, passing as arguments

- # the current object and <tt>:foo</tt>.

- def notify_observers(*args)

- observer_instances.each { |observer| observer.update(*args) }

- end

-

- # Returns the total number of instantiated observers.

- #

- # class Foo

- # include ActiveModel::Observing

- #

- # attr_accessor :status

- # end

- #

- # class FooObserver < ActiveModel::Observer

- # def on_spec(record, *args)

- # record.status = true

- # end

- # end

- #

- # Foo.observers = FooObserver

- # Foo.observers_count # => 0

- # Foo.instantiate_observers

- # Foo.observers_count # => 1

- def observers_count

- observer_instances.size

- end

-

- # <tt>count_observers</tt> is deprecated. Use #observers_count.

- def count_observers

- msg = "count_observers is deprecated in favor of observers_count"

- ActiveSupport::Deprecation.warn(msg)

- observers_count

- end

-

- protected

- def instantiate_observer(observer) #:nodoc:

- # string/symbol

- if observer.respond_to?(:to_sym)

- observer = observer.to_s.camelize.constantize

- end

- if observer.respond_to?(:instance)

- observer.instance

- else

- raise ArgumentError,

- "#{observer} must be a lowercase, underscored class name (or " +

- "the class itself) responding to the method :instance. " +

- "Example: Person.observers = :big_brother # calls " +

- "BigBrother.instance"

- end

- end

-

- # Notify observers when the observed class is subclassed.

- def inherited(subclass) #:nodoc:

- super

- notify_observers :observed_class_inherited, subclass

- end

- end

-

- # Notify a change to the list of observers.

- #

- # class Foo

- # include ActiveModel::Observing

- #

- # attr_accessor :status

- # end

- #

- # class FooObserver < ActiveModel::Observer

- # def on_spec(record, *args)

- # record.status = true

- # end

- # end

- #

- # Foo.observers = FooObserver

- # Foo.instantiate_observers # => [FooObserver]

- #

- # foo = Foo.new

- # foo.status = false

- # foo.notify_observers(:on_spec)

- # foo.status # => true

- #

- # See ActiveModel::Observing::ClassMethods.notify_observers for more

- # information.

- def notify_observers(method, *extra_args)

- self.class.notify_observers(method, self, *extra_args)

- end

- end

-

- # == Active Model Observers

- #

- # Observer classes respond to life cycle callbacks to implement trigger-like

- # behavior outside the original class. This is a great way to reduce the

- # clutter that normally comes when the model class is burdened with

- # functionality that doesn't pertain to the core responsibility of the

- # class.

- #

- # class CommentObserver < ActiveModel::Observer

- # def after_save(comment)

- # Notifications.comment('admin@do.com', 'New comment was posted', comment).deliver

- # end

- # end

- #

- # This Observer sends an email when a <tt>Comment#save</tt> is finished.

- #

- # class ContactObserver < ActiveModel::Observer

- # def after_create(contact)

- # contact.logger.info('New contact added!')

- # end

- #

- # def after_destroy(contact)

- # contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")

- # end

- # end

- #

- # This Observer uses logger to log when specific callbacks are triggered.

- #

- # == Observing a class that can't be inferred

- #

- # Observers will by default be mapped to the class with which they share a

- # name. So <tt>CommentObserver</tt> will be tied to observing <tt>Comment</tt>,

- # <tt>ProductManagerObserver</tt> to <tt>ProductManager</tt>, and so on. If

- # you want to name your observer differently than the class you're interested

- # in observing, you can use the <tt>Observer.observe</tt> class method which

- # takes either the concrete class (<tt>Product</tt>) or a symbol for that

- # class (<tt>:product</tt>):

- #

- # class AuditObserver < ActiveModel::Observer

- # observe :account

- #

- # def after_update(account)

- # AuditTrail.new(account, 'UPDATED')

- # end

- # end

- #

- # If the audit observer needs to watch more than one kind of object, this can

- # be specified with multiple arguments:

- #

- # class AuditObserver < ActiveModel::Observer

- # observe :account, :balance

- #

- # def after_update(record)

- # AuditTrail.new(record, 'UPDATED')

- # end

- # end

- #

- # The <tt>AuditObserver</tt> will now act on both updates to <tt>Account</tt>

- # and <tt>Balance</tt> by treating them both as records.

- #

- # If you're using an Observer in a Rails application with Active Record, be

- # sure to read about the necessary configuration in the documentation for

- # ActiveRecord::Observer.

- class Observer

- include Singleton

- extend ActiveSupport::DescendantsTracker

-

- class << self

- # Attaches the observer to the supplied model classes.

- #

- # class AuditObserver < ActiveModel::Observer

- # observe :account, :balance

- # end

- #

- # AuditObserver.observed_classes # => [Account, Balance]

- def observe(*models)

- models.flatten!

- models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model }

- singleton_class.redefine_method(:observed_classes) { models }

- end

-

- # Returns an array of Classes to observe.

- #

- # AccountObserver.observed_classes # => [Account]

- #

- # You can override this instead of using the +observe+ helper.

- #

- # class AuditObserver < ActiveModel::Observer

- # def self.observed_classes

- # [Account, Balance]

- # end

- # end

- def observed_classes

- Array(observed_class)

- end

-

- # Returns the class observed by default. It's inferred from the observer's

- # class name.

- #

- # PersonObserver.observed_class # => Person

- # AccountObserver.observed_class # => Account

- def observed_class

- name[/(.*)Observer/, 1].try :constantize

- end

- end

-

- # Start observing the declared classes and their subclasses.

- # Called automatically by the instance method.

- def initialize #:nodoc:

- observed_classes.each { |klass| add_observer!(klass) }

- end

-

- def observed_classes #:nodoc:

- self.class.observed_classes

- end

-

- # Send observed_method(object) if the method exists and

- # the observer is enabled for the given object's class.

- def update(observed_method, object, *extra_args, &block) #:nodoc:

- return if !respond_to?(observed_method) || disabled_for?(object)

- send(observed_method, object, *extra_args, &block)

- 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])

- add_observer!(subclass)

- end

-

- protected

- def add_observer!(klass) #:nodoc:

- klass.add_observer(self)

- end

-

- # Returns true if notifications are disabled for this object.

- def disabled_for?(object) #:nodoc:

- klass = object.class

- return false unless klass.respond_to?(:observers)

- klass.observers.disabled_for?(self)

- end

- end

-end

- class Railtie < Rails::Railtie

-end \ No newline at end of file

- # You need to add bcrypt-ruby (~> 3.0.0) to Gemfile to use #has_secure_password:

- # gem 'bcrypt-ruby', '~> 3.0.0'

- # user.save # => false, password required

- # user.save # => false, confirmation doesn't match

- # user.save # => true

- # user.authenticate('notright') # => false

- # user.authenticate('mUc3m00RsqyRe') # => user

- # User.find_by_name('david').try(:authenticate, 'notright') # => false

- # User.find_by_name('david').try(:authenticate, 'mUc3m00RsqyRe') # => user

- gem 'bcrypt-ruby', '~> 3.0.0'

- require 'bcrypt'

- validates_confirmation_of :password

- validates_presence_of :password, :on => :create

-

- include InstanceMethodsOnActivation

-

- #  user.authenticate('mUc3m00RsqyRe') # => user

- # user.password_digest # => "$2a$10$4LEA7r4YmNHtvlAvHhsYAeZmk/xeUVtMTYqwIvYY76EW5GUqDiP4."

- self.password_digest = BCrypt::Password.create(unencrypted_password)

- # == Active Model Serialization

- # person.serializable_hash(only: :name) # => {"name"=>"bob"}

- # == Active Model JSON Serializer

- # instance_variable_set("@#{key}", value)

- # == Active Model XML Serializer

- value = value.in_time_zone if value.respond_to?(:in_time_zone)

- options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])

- args << {:xmlns => options[:namespace]} if options[:namespace]

- args << {:type => options[:type]} if options[:type] && !options[:skip_types]

- type = options[:skip_types] ? { } : {:type => "array"}

- record_type = {:type => record_class}

- records.to_xml(merged_options)

- # Sets the model +attributes+ from a JSON string. Returns +self+.

- # == Active Model Translation

- options = { :count => 1 }.merge!(options)

-require 'active_model/errors'

-require 'active_model/validations/callbacks'

- # == Active Model Validations

- # person.errors.messages # => {:first_name=>["starts with z."]}

- define_callbacks :validate, :scope => :name

- options[:if].unshift("validation_context == :#{options[:on]}")

- # # #<OtherValidator:0x007fbff403d930 @options={:on=>:create}>,

- # # #<StrictValidator:0x007fbff3204a30 @options={:strict=>true}>

- # # #<ActiveModel::Validations::InclusionValidator:0x007fe603bb8780 @attributes=[:age], @options={:in=>0..99}>

- # person.errors # => #<ActiveModel::Errors:0x007fe603816640 @messages={:name=>["can't be blank"]}>

- # person.valid? # => false

- # person.valid? # => true

- # person.invalid? # => true

- # person.invalid? # => false

-Dir[File.dirname(__FILE__) + "/validations/*.rb"].sort.each do |path|

- filename = File.basename(path)

- require "active_model/validations/#{filename}"

-end

- # == Active Model Acceptance Validator

- class AcceptanceValidator < EachValidator #:nodoc:

- super({ :allow_nil => true, :accept => "1" }.merge!(options))

- def setup(klass)

- # validates_acceptance_of :eula, message: "must be abided"

-require 'active_support/callbacks'

-

- # == Active Model Validation callbacks

- define_callbacks :validation, :terminator => "result == false", :skip_after_callbacks_if_terminated => true, :scope => [:kind, :name]

- options[:if].unshift("#{options[:on]}.include? self.validation_context")

- # person.status # => false

- #  person.name = 'bob'

- ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " <<

- exclusions = if delimiter.respond_to?(:call)

- delimiter.call(record)

- elsif delimiter.respond_to?(:to_sym)

- record.send(delimiter)

- else

- delimiter

- end

- exclusions.send(inclusion_method(exclusions), value)

- # In Ruby 1.9 <tt>Range#include?</tt> on non-numeric ranges checks all possible values in the

- # range for equality, so it may be slow for large ranges. The new <tt>Range#cover?</tt>

- # uses the previous logic of comparing a value with the range endpoints.

- enumerable.is_a?(Range) ? :cover? : :include?

- # == Active Model Confirmation Validator

- class ConfirmationValidator < EachValidator #:nodoc:

- record.errors.add(:"#{attribute}_confirmation", :confirmation, options.merge(:attribute => human_attribute_name))

- def setup(klass)

- klass.send(:attr_accessor, *attributes.map do |attribute|

- # == Active Model Exclusion Validator

- class ExclusionValidator < EachValidator #:nodoc:

- record.errors.add(attribute, :exclusion, options.except(:in, :within).merge!(:value => value))

- # == Active Model Format Validator

- class FormatValidator < EachValidator #:nodoc:

- record.errors.add(attribute, :invalid, options.except(name).merge!(:value => value))

- # == Active Model Inclusion Validator

- class InclusionValidator < EachValidator #:nodoc:

- record.errors.add(attribute, :inclusion, options.except(:in, :within).merge!(:value => value))

- # enumerable is a range the test is performed with <tt>Range#cover?</tt>,

- # == Active Model Length Validator

- class LengthValidator < EachValidator #:nodoc:

- MESSAGES = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }.freeze

- CHECKS = { :is => :==, :minimum => :>=, :maximum => :<= }.freeze

-

- next if value_length.send(validity_check, check_value)

- # * <tt>:maximum</tt> - The maximum size of the attribute.

- # == Active Model Numericality Validator

- class NumericalityValidator < EachValidator #:nodoc:

- CHECKS = { :greater_than => :>, :greater_than_or_equal_to => :>=,

- :equal_to => :==, :less_than => :<, :less_than_or_equal_to => :<=,

- :odd => :odd?, :even => :even?, :other_than => :!= }.freeze

- before_type_cast = "#{attr_name}_before_type_cast"

- raw_value = record.send(before_type_cast) if record.respond_to?(before_type_cast.to_sym)

- record.errors.add(attr_name, option, filtered_options(value).merge(:count => option_value))

- options.except(*RESERVED_OPTIONS).merge!(:value => value)

- # validates_numericality_of :width, less_than: Proc.new { |person| person.height }

- # == Active Model Presence Validator

- class PresenceValidator < EachValidator #:nodoc:

- def validate(record)

- record.errors.add_on_blank(attributes, options)

- # == Active Model validates method

- defaults.merge!(:attributes => attributes)

- #  include ActiveModel::Validations

- #  person.name = ''

- #  person.valid?

- def _validates_default_keys #:nodoc:

- def _parse_validates_options(options) #:nodoc:

- { :in => options }

- { :with => options }

- class WithValidator < EachValidator #:nodoc:

- validator.setup(self) if validator.respond_to?(:setup)

- # == Active Model Validator

- # validates :title, :presence => true

- # Validator may also define a +setup+ instance method which will get called

- # with the class that using that validator as its argument. This can be

- # useful when there are prerequisites such as an +attr_accessor+ being present.

- # def setup(klass)

- # klass.send :attr_accessor, :custom_attribute

- #

- # This setup method is only called when used with validation macros or the

- # class level <tt>validates_with</tt> method.

- def initialize(options)

- @options = options.freeze

- # PresenceValidator.new.kind # => :presence

- # UniquenessValidator.new.kind # => :uniqueness 

- raise ":attributes cannot be blank" if @attributes.empty?

- module VERSION #:nodoc:

- MAJOR = 4

- MINOR = 0

- TINY = 0

- PRE = "beta"

- STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

- { :foo => 'value of foo', :baz => 'value of baz' }

- { :begin => 'value of begin', :end => 'value of end' }

- test 'acessing a suffixed attribute' do

- test 'explicitly specifying an empty prefix/suffix is deprecated' do

- klass = Class.new(ModelWithAttributes)

-

- assert_deprecated { klass.attribute_method_suffix '' }

- assert_deprecated { klass.attribute_method_prefix '' }

-

- klass.define_attribute_methods(:foo)

-

- assert_equal 'value of foo', klass.new.foo

- end

-

- define_model_callbacks :initialize, :only => :after

- define_model_callbacks :multiple, :only => [:before, :around]

- define_model_callbacks :empty, :only => []

- test "after_create callbacks with both callbacks declared in differnt lines" do

- assert_equal [1], Contact.new(:id => 1).to_key

- assert_equal "1", Contact.new(:id => 1).to_param

-require 'cases/helper'

-require 'models/project'

-

-class DeprecatedMassAssignmentSecurityTest < ActiveModel::TestCase

- def test_attr_accessible_raise_error

- assert_raise RuntimeError, /protected_attributes/ do

- Project.attr_accessible :username

- end

- end

-

- def test_attr_protected_raise_error

- assert_raise RuntimeError, /protected_attributes/ do

- Project.attr_protected :username

- end

- end

-end

- define_attribute_methods :name, :color

- @previously_changed = changes

- @changed_attributes.clear

- test "list of changed attributes" do

- #assert !@model.name_changed #Doesn't work yet

- attr_accessor :name

- test "should return true if no errors" do

- test "method validate! should work" do

- test 'should be able to assign error' do

- test 'should be able to add an error on an attribute' do

- test "should be able to add an error with a symbol" do

- test "should be able to add an error with a proc" do

- test "added? should be true if that error was added" do

- test "added? should handle when message is a symbol" do

- test "added? should handle when message is a proc" do

- test "added? should default message to :invalid" do

- person.errors.add(:name, :invalid)

- test "added? should be true when several errors are present, and we ask for one of them" do

- test "added? should be false if no errors are present" do

- test "added? should be false when an error is present, but we check for another error" do

- test 'should respond to size' do

- test 'to_a should return an array' do

- test 'to_hash should return a hash' do

- assert_instance_of ::Hash, person.errors.to_hash

- test 'full_messages should return an array of error messages, with the attribute name included' do

- assert_equal ["name can not be blank", "name can not be nil"], person.errors.to_a

- test 'full_message should return the given message if attribute equals :base' do

- test 'full_message should return the given message with the attribute name included' do

- test 'should return a JSON hash representation of the errors' do

- person.errors.add(:name, "can not be blank")

- person.errors.add(:name, "can not be nil")

- person.errors.add(:email, "is invalid")

- hash = person.errors.as_json

- assert_equal ["can not be blank", "can not be nil"], hash[:name]

- assert_equal ["is invalid"], hash[:email]

- test 'should return a JSON hash representation of the errors with full messages' do

- person.errors.add(:name, "can not be blank")

- person.errors.add(:name, "can not be nil")

- person.errors.add(:email, "is invalid")

- hash = person.errors.as_json(:full_messages => true)

- assert_equal ["name can not be blank", "name can not be nil"], hash[:name]

- assert_equal ["email is invalid"], hash[:email]

- test "generate_message should work without i18n_scope" do

-end

-require 'minitest/autorun'

- object = BasicModel.new(:attr => "value")

- assert_equal object.attr, "value"

- assert uncountable?(@uncountable), "Expected 'sheep' to be uncoutable"

-require 'cases/helper'

-require 'models/observers'

-

-class ObserverArrayTest < ActiveModel::TestCase

- def teardown

- ORM.observers.enable :all

- Budget.observers.enable :all

- Widget.observers.enable :all

- end

-

- def assert_observer_notified(model_class, observer_class)

- observer_class.instance.before_save_invocations.clear

- model_instance = model_class.new

- model_instance.save

- assert_equal [model_instance], observer_class.instance.before_save_invocations

- end

-

- def assert_observer_not_notified(model_class, observer_class)

- observer_class.instance.before_save_invocations.clear

- model_instance = model_class.new

- model_instance.save

- assert_equal [], observer_class.instance.before_save_invocations

- end

-

- test "all observers are enabled by default" do

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can disable individual observers using a class constant" do

- ORM.observers.disable WidgetObserver

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can enable individual observers using a class constant" do

- ORM.observers.disable :all

- ORM.observers.enable AuditTrail

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can disable individual observers using a symbol" do

- ORM.observers.disable :budget_observer

-

- assert_observer_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can enable individual observers using a symbol" do

- ORM.observers.disable :all

- ORM.observers.enable :audit_trail

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can disable multiple observers at a time" do

- ORM.observers.disable :widget_observer, :budget_observer

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can enable multiple observers at a time" do

- ORM.observers.disable :all

- ORM.observers.enable :widget_observer, :budget_observer

-

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_not_notified Budget, AuditTrail

- end

-

- test "can disable all observers using :all" do

- ORM.observers.disable :all

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_not_notified Budget, AuditTrail

- end

-

- test "can enable all observers using :all" do

- ORM.observers.disable :all

- ORM.observers.enable :all

-

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can disable observers on individual models without affecting those observers on other models" do

- Widget.observers.disable :all

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can enable observers on individual models without affecting those observers on other models" do

- ORM.observers.disable :all

- Budget.observers.enable AuditTrail

-

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can disable observers for the duration of a block" do

- yielded = false

- ORM.observers.disable :budget_observer do

- yielded = true

- assert_observer_notified Widget, WidgetObserver

- assert_observer_not_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- assert yielded

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "can enable observers for the duration of a block" do

- yielded = false

- Widget.observers.disable :all

-

- Widget.observers.enable :all do

- yielded = true

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- assert yielded

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "raises an appropriate error when a developer accidentally enables or disables the wrong class (i.e. Widget instead of WidgetObserver)" do

- assert_raise ArgumentError do

- ORM.observers.enable :widget

- end

-

- assert_raise ArgumentError do

- ORM.observers.enable Widget

- end

-

- assert_raise ArgumentError do

- ORM.observers.disable :widget

- end

-

- assert_raise ArgumentError do

- ORM.observers.disable Widget

- end

- end

-

- test "allows #enable at the superclass level to override #disable at the subclass level when called last" do

- Widget.observers.disable :all

- ORM.observers.enable :all

-

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- test "allows #disable at the superclass level to override #enable at the subclass level when called last" do

- Budget.observers.enable :audit_trail

- ORM.observers.disable :audit_trail

-

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_not_notified Budget, AuditTrail

- end

-

- test "can use the block form at different levels of the hierarchy" do

- yielded = false

- Widget.observers.disable :all

-

- ORM.observers.enable :all do

- yielded = true

- assert_observer_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-

- assert yielded

- assert_observer_not_notified Widget, WidgetObserver

- assert_observer_notified Budget, BudgetObserver

- assert_observer_not_notified Widget, AuditTrail

- assert_observer_notified Budget, AuditTrail

- end

-end

-

-require 'cases/helper'

-

-class ObservedModel

- include ActiveModel::Observing

-

- class Observer

- end

-end

-

-class FooObserver < ActiveModel::Observer

- class << self

- public :new

- end

-

- attr_accessor :stub

-

- def on_spec(record, *args)

- stub.event_with(record, *args) if stub

- end

-

- def around_save(record)

- yield :in_around_save

- end

-end

-

-class Foo

- include ActiveModel::Observing

-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 "uses an ObserverArray so observers can be disabled" do

- ObservedModel.observers = [:foo, :bar]

- assert ObservedModel.observers.is_a?(ActiveModel::ObserverArray)

- 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 "raises an appropriate error when a developer accidentally adds the wrong class (i.e. Widget instead of WidgetObserver)" do

- assert_raise ArgumentError do

- ObservedModel.observers = ['string']

- ObservedModel.instantiate_observers

- end

- assert_raise ArgumentError do

- ObservedModel.observers = [:string]

- ObservedModel.instantiate_observers

- end

- assert_raise ArgumentError do

- ObservedModel.observers = [String]

- ObservedModel.instantiate_observers

- end

- end

-

- test "passes observers to subclasses" do

- FooObserver.instance

- bar = Class.new(Foo)

- assert_equal Foo.observers_count, bar.observers_count

- end

-end

-

-class ObserverTest < ActiveModel::TestCase

- def setup

- ObservedModel.observers = :foo_observer

- FooObserver.singleton_class.instance_eval do

- alias_method :original_observed_classes, :observed_classes

- end

- end

-

- def teardown

- FooObserver.singleton_class.instance_eval do

- undef_method :observed_classes

- alias_method :observed_classes, :original_observed_classes

- end

- end

-

- test "guesses implicit observable model name" do

- assert_equal Foo, FooObserver.observed_class

- end

-

- test "tracks implicit observable models" do

- instance = FooObserver.new

- assert_equal [Foo], instance.observed_classes

- end

-

- test "tracks explicit observed model class" do

- FooObserver.observe ObservedModel

- instance = FooObserver.new

- assert_equal [ObservedModel], instance.observed_classes

- end

-

- test "tracks explicit observed model as string" do

- FooObserver.observe 'observed_model'

- instance = FooObserver.new

- assert_equal [ObservedModel], instance.observed_classes

- end

-

- test "tracks explicit observed model as symbol" do

- FooObserver.observe :observed_model

- instance = FooObserver.new

- assert_equal [ObservedModel], instance.observed_classes

- end

-

- test "calls existing observer event" do

- foo = Foo.new

- FooObserver.instance.stub = stub

- FooObserver.instance.stub.expects(:event_with).with(foo)

- Foo.notify_observers(:on_spec, foo)

- end

-

- test "calls existing observer event from the instance" do

- foo = Foo.new

- FooObserver.instance.stub = stub

- FooObserver.instance.stub.expects(:event_with).with(foo)

- foo.notify_observers(:on_spec)

- end

-

- test "passes extra arguments" do

- foo = Foo.new

- FooObserver.instance.stub = stub

- FooObserver.instance.stub.expects(:event_with).with(foo, :bar)

- Foo.send(:notify_observers, :on_spec, foo, :bar)

- end

-

- test "skips nonexistent observer event" do

- foo = Foo.new

- Foo.notify_observers(:whatever, foo)

- end

-

- test "update passes a block on to the observer" do

- yielded_value = nil

- FooObserver.instance.update(:around_save, Foo.new) do |val|

- yielded_value = val

- end

- assert_equal :in_around_save, yielded_value

- end

-

- test "observe redefines observed_classes class method" do

- class BarObserver < ActiveModel::Observer

- observe :foo

- end

-

- assert_equal [Foo], BarObserver.observed_classes

-

- BarObserver.observe(ObservedModel)

- assert_equal [ObservedModel], BarObserver.observed_classes

- end

-end

-

-

- assert_equal expected, @user.serializable_hash(:only => [:name])

- assert_equal expected, @user.serializable_hash(:except => [:name])

- assert_equal expected, @user.serializable_hash(:methods => [:foo])

- assert_equal expected, @user.serializable_hash(:only => [], :methods => [:foo])

- assert_equal expected, @user.serializable_hash(:except => [:name, :email], :methods => [:foo])

- assert_equal expected, @user.serializable_hash(:methods => [:bar])

- assert_equal expected, @user.serializable_hash(:only => :name)

- assert_equal expected, @user.serializable_hash(:include => :address)

- assert_equal expected, @user.serializable_hash(:include => :friends)

- assert_equal expected, @user.serializable_hash(:include => :friends)

- assert_equal expected, @user.serializable_hash(:include => :friends)

- assert_equal expected, @user.serializable_hash(:include => [:address, :friends])

- assert_equal expected, @user.serializable_hash(:include => {:address => {:only => "street"}})

- assert_equal expected, @user.serializable_hash(:include => {:friends => {:include => :friends}})

- assert_equal expected, @user.serializable_hash(:only => :name, :include => {:friends => {:only => :name}})

- assert_equal expected, @user.serializable_hash(:except => :gender, :include => {:friends => {:except => :gender}})

- assert_equal expected, @user.serializable_hash(:include => [{:address => {:only => "street"}}, :friends])

- extend ActiveModel::Naming

- json = @contact.to_json(:only => [:name, :age])

- test "custom as_json options should be extendible" do

- extend ActiveModel::Naming

- attr_accessor :address, :friends

- instance_values.except("address", "friends")

- extend ActiveModel::Naming

- super(options.merge(:only => [:name, :age]))

- @contact.address.street = "123 Lane"

- @contact.address.state = "CA"

- @contact.address.zip = 11111

- @xml = @contact.to_xml :namespace => "http://xml.rubyonrails.org/contact"

- @xml = @contact.to_xml :root => 'xml_contact'

- @xml = @contact.to_xml :root => 'xml_contact', :dasherize => false

- @xml = @contact.to_xml :root => 'xml_contact', :camelize => true

- @xml = @contact.to_xml :root => 'xml_contact', :camelize => :lower

- @xml = @contact.to_xml :skip_types => true

- assert_match %r{<pseudonyms nil=\"true\"/>}, @contact.to_xml(:methods => :pseudonyms)

- assert_match %r{<created-at type=\"dateTime\">2006-08-01T00:00:00Z</created-at>}, @contact.to_xml

- assert_match %r{<awesome type=\"boolean\">false</awesome>}, @contact.to_xml

- assert_match %r{<social type=\"array\">\s*<social>twitter</social>\s*<social>github</social>\s*</social>}, @contact.to_xml(:methods => :social)

- assert_match %r{<network>\s*<git type=\"symbol\">github</git>\s*</network>}, @contact.to_xml(:methods => :network)

- assert_match %r{<preferences type=\"yaml\">--- !ruby/struct:Customer(\s*)\nname: John\n</preferences>}, @contact.to_xml

- xml = @contact.to_xml(:procs => [ proc ])

- xml = @contact.to_xml(:procs => [ proc ])

- xml = @contact.to_xml :type => 'Contact'

- xml = @contact.to_xml :include => :address, :indent => 0

- assert xml.include?(@contact.address.to_xml(:indent => 0, :skip_instruct => true))

- xml = @contact.to_xml :include => :friends, :indent => 0

- xml = @contact.to_xml :include => :friends, :indent => 0

- xml = @contact.to_xml :indent => 0, :skip_instruct => true, :include => [ :address, :friends ]

- assert xml.include?(@contact.address.to_xml(:indent => 0, :skip_instruct => true))

- xml = @contact.to_xml :indent => 0, :skip_instruct => true, :include => { :address => { :only => :city } }

- xml = @contact.to_xml :include => :friends, :indent => 0, :skip_types => true

- xml = @contact.to_xml :skip_types => true, :include => :address, :indent => 0

- xml = @contact.to_xml :camelize => true, :include => :address, :indent => 0

- xml = @contact.to_xml :dasherize => false, :include => :address, :indent => 0

- xml = @contact.to_xml :skip_types => true, :include => { :address => { :skip_types => false } }, :indent => 0

- xml = @contact.to_xml :camelize => true, :include => { :address => { :camelize => false } }, :indent => 0

- xml = @contact.to_xml :dasherize => false, :include => { :address => { :dasherize => true } }, :indent => 0

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:person => {:name => 'person name attribute'} } }

- I18n.backend.store_translations 'en', :attributes => { :name => 'name default attribute' }

- assert_equal 'name default attribute', Person.human_attribute_name('name', :default => "name default attribute")

- I18n.backend.store_translations 'en', :default_name => 'name default attribute'

- assert_equal 'name default attribute', Person.human_attribute_name('name', :default => :default_name)

- assert_equal 'Name', Person.human_attribute_name('name', :default => :default_name)

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:person => {:name => 'person name attribute'} } }

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:child => {:name => 'child name attribute'} } }

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:person => {:name => 'person name attribute'} } }

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:person => {:gender => 'person gender'}, :"person/gender" => {:attribute => 'person gender attribute'}}}

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:"person/contacts/addresses" => {:street => 'Deeply Nested Address Street'}}}

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:"person/addresses" => {:street => 'Person Address Street'}}}

- I18n.backend.store_translations 'en', :activemodel => {:attributes => {:addresses => {:street => 'Cool Address Street'}}}

- I18n.backend.store_translations 'en', :activemodel => {:models => {:person => 'person model'} }

- I18n.backend.store_translations 'en', :activemodel => {:models => {:child => 'child model'} }

- I18n.backend.store_translations 'en', :activemodel => {:models => {:person => 'person model'} }

- options = { :default => 'person model' }

- assert_equal({ :default => 'person model' }, options)

- options = { :default => 'Cool gender' }

- assert_equal({ :default => 'Cool gender' }, options)

- Topic.validates_acceptance_of(:eula, :message => "must be abided")

- Topic.validates_acceptance_of(:terms_of_service, :accept => "I agree.")

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :if => :condition_is_true )

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :unless => :condition_is_true )

- assert t.errors[:title].empty?

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :if => :condition_is_true_but_its_not )

- assert t.errors[:title].empty?

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :unless => :condition_is_true_but_its_not )

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :if => "a = 1; a == 1" )

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :unless => "a = 1; a == 1" )

- assert t.errors[:title].empty?

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :if => "false")

- assert t.errors[:title].empty?

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}", :unless => "false")

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}",

- :if => Proc.new { |r| r.content.size > 4 } )

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}",

- :unless => Proc.new { |r| r.content.size > 4 } )

- assert t.errors[:title].empty?

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}",

- :if => Proc.new { |r| r.title != "uhohuhoh"} )

- assert t.errors[:title].empty?

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}",

- :unless => Proc.new { |r| r.title != "uhohuhoh"} )

- Topic.validates_presence_of(:author_name, :if => "title.to_s.match('important')")

- assert t.errors[:author_name].empty?, "A topic without an 'important' title should not require an author"

- t = Topic.new(:author_name => "Plutarch")

- :errors => {:messages => {:confirmation => "doesn't match %{attribute}"}},

- :activemodel => {:attributes => {:topic => {:title => 'Test Title'}}}

- Topic.validates_exclusion_of( :title, :in => %w( abe monkey ) )

- Topic.validates_exclusion_of( :title, :in => %w( abe monkey ), :message => "option %{value} is restricted" )

- Topic.validates_exclusion_of( :title, :within => %w( abe monkey ) )

- Person.validates_exclusion_of :karma, :in => %w( abe monkey )

- Topic.validates_exclusion_of :title, :in => lambda{ |topic| topic.author_name == "sikachu" ? %w( monkey elephant ) : %w( abe wasabi ) }

- Person.validates_exclusion_of :karma, :in => :reserved_karmas

- Topic.validates_format_of(:title, :content, :with => /\AValidation\smacros \w+!\z/, :message => "is bad data")

- Topic.validates_format_of(:title, :with => /\AValidation\smacros \w+!\z/, :allow_blank => true)

- Topic.validates_format_of(:title, :content, :with => /\A[1-9][0-9]*\z/, :message => "is bad data")

- Topic.validates_format_of(:title, :with => /\AValid Title\z/, :message => "can't be %{value}")

- t = Topic.new(:title => 'Invalid title')

- assert_raise(ArgumentError) { Topic.validates_format_of(:title, :with => /^Valid Title$/) }

- Topic.validates_format_of(:title, :with => /^Valid Title$/, :multiline => true)

- Topic.validates_format_of(:title, :without => /foo/, :message => "should not contain foo")

- assert_raise(ArgumentError) { Topic.validates_format_of(:title, :with => /this/, :without => /that/) }

- assert_raise(ArgumentError) { Topic.validates_format_of(:title, :with => "clearly not a regexp") }

- assert_raise(ArgumentError) { Topic.validates_format_of(:title, :without => "clearly not a regexp") }

- Topic.validates_format_of :content, :with => lambda{ |topic| topic.title == "digit" ? /\A\d+\Z/ : /\A\S+\Z/ }

- Topic.validates_format_of :content, :without => lambda{ |topic| topic.title == "characters" ? /\A\d+\Z/ : /\A\S+\Z/ }

- Person.validates_format_of :karma, :with => /\A\d+\Z/

- # validates_inclusion_of: generate_message(attr_name, :inclusion, :message => custom_message, :value => value)

- assert_equal 'is not included in the list', @person.errors.generate_message(:title, :inclusion, :value => 'title')

- assert_equal 'custom message title', @person.errors.generate_message(:title, :inclusion, :message => 'custom message %{value}', :value => 'title')

- # validates_exclusion_of: generate_message(attr_name, :exclusion, :message => custom_message, :value => value)

- assert_equal 'is reserved', @person.errors.generate_message(:title, :exclusion, :value => 'title')

- assert_equal 'custom message title', @person.errors.generate_message(:title, :exclusion, :message => 'custom message %{value}', :value => 'title')

- # validates_format_of: generate_message(attr_name, :invalid, :message => custom_message, :value => value)

- assert_equal 'is invalid', @person.errors.generate_message(:title, :invalid, :value => 'title')

- assert_equal 'custom message title', @person.errors.generate_message(:title, :invalid, :message => 'custom message %{value}', :value => 'title')

- # validates_confirmation_of: generate_message(attr_name, :confirmation, :message => custom_message)

- assert_equal 'custom message', @person.errors.generate_message(:title, :confirmation, :message => 'custom message')

- # validates_acceptance_of: generate_message(attr_name, :accepted, :message => custom_message)

- assert_equal 'custom message', @person.errors.generate_message(:title, :accepted, :message => 'custom message')

- # add_on_empty: generate_message(attr, :empty, :message => custom_message)

- assert_equal 'custom message', @person.errors.generate_message(:title, :empty, :message => 'custom message')

- # add_on_blank: generate_message(attr, :blank, :message => custom_message)

- assert_equal 'custom message', @person.errors.generate_message(:title, :blank, :message => 'custom message')

- # validates_length_of: generate_message(attr, :too_long, :message => custom_message, :count => option_value.end)

- assert_equal "is too long (maximum is 10 characters)", @person.errors.generate_message(:title, :too_long, :count => 10)

- assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_long, :message => 'custom message %{count}', :count => 10)

- # validates_length_of: generate_message(attr, :too_short, :default => custom_message, :count => option_value.begin)

- assert_equal "is too short (minimum is 10 characters)", @person.errors.generate_message(:title, :too_short, :count => 10)

- assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_short, :message => 'custom message %{count}', :count => 10)

- # validates_length_of: generate_message(attr, :wrong_length, :message => custom_message, :count => option_value)

- assert_equal "is the wrong length (should be 10 characters)", @person.errors.generate_message(:title, :wrong_length, :count => 10)

- assert_equal 'custom message 10', @person.errors.generate_message(:title, :wrong_length, :message => 'custom message %{count}', :count => 10)

- # validates_numericality_of: generate_message(attr_name, :not_a_number, :value => raw_value, :message => custom_message)

- assert_equal "is not a number", @person.errors.generate_message(:title, :not_a_number, :value => 'title')

- assert_equal 'custom message title', @person.errors.generate_message(:title, :not_a_number, :message => 'custom message %{value}', :value => 'title')

- # validates_numericality_of: generate_message(attr_name, option, :value => raw_value, :default => custom_message)

- assert_equal "must be greater than 10", @person.errors.generate_message(:title, :greater_than, :value => 'title', :count => 10)

- assert_equal "must be greater than or equal to 10", @person.errors.generate_message(:title, :greater_than_or_equal_to, :value => 'title', :count => 10)

- assert_equal "must be equal to 10", @person.errors.generate_message(:title, :equal_to, :value => 'title', :count => 10)

- assert_equal "must be less than 10", @person.errors.generate_message(:title, :less_than, :value => 'title', :count => 10)

- assert_equal "must be less than or equal to 10", @person.errors.generate_message(:title, :less_than_or_equal_to, :value => 'title', :count => 10)

- assert_equal "must be odd", @person.errors.generate_message(:title, :odd, :value => 'title', :count => 10)

- assert_equal "must be even", @person.errors.generate_message(:title, :even, :value => 'title', :count => 10)

- I18n.backend.store_translations('en', :errors => {:messages => {:custom => nil}})

- def test_errors_add_on_empty_generates_message

- @person.errors.expects(:generate_message).with(:title, :empty, {})

- @person.errors.add_on_empty :title

- end

-

- def test_errors_add_on_empty_generates_message_with_custom_default_message

- @person.errors.expects(:generate_message).with(:title, :empty, {:message => 'custom'})

- @person.errors.add_on_empty :title, :message => 'custom'

- end

-

- def test_errors_add_on_blank_generates_message

- @person.errors.expects(:generate_message).with(:title, :blank, {})

- @person.errors.add_on_blank :title

- end

-

- def test_errors_add_on_blank_generates_message_with_custom_default_message

- @person.errors.expects(:generate_message).with(:title, :blank, {:message => 'custom'})

- @person.errors.add_on_blank :title, :message => 'custom'

- end

-

- I18n.backend.store_translations('en', :errors => {

- :messages => { :too_short => '猫舌' }})

- Person.validates_length_of :title, :within => 3..5

- Person.expects(:human_attribute_name).with(:name, :default => 'Name').returns("Person's name")

- I18n.backend.store_translations('en', :errors => {:format => "Field %{attribute} %{message}"})

- [ "given custom message", {:message => "custom"}, {:message => "custom"}],

- [ "given if condition", {:if => lambda { true }}, {}],

- [ "given unless condition", {:unless => lambda { false }}, {}],

- [ "given option that is not reserved", {:format => "jpg"}, {:format => "jpg" }]

- @person.errors.expects(:generate_message).with(:title_confirmation, :confirmation, generate_message_options.merge(:attribute => 'Title'))

- Person.validates_acceptance_of :title, validation_options.merge(:allow_nil => false)

- Person.validates_length_of :title, validation_options.merge(:within => 3..5)

- @person.errors.expects(:generate_message).with(:title, :too_short, generate_message_options.merge(:count => 3))

- Person.validates_length_of :title, validation_options.merge(:within => 3..5)

- @person.errors.expects(:generate_message).with(:title, :too_long, generate_message_options.merge(:count => 5))

- Person.validates_length_of :title, validation_options.merge(:is => 5)

- @person.errors.expects(:generate_message).with(:title, :wrong_length, generate_message_options.merge(:count => 5))

- Person.validates_format_of :title, validation_options.merge(:with => /\A[1-9][0-9]*\z/)

- @person.errors.expects(:generate_message).with(:title, :invalid, generate_message_options.merge(:value => '72x'))

- Person.validates_inclusion_of :title, validation_options.merge(:in => %w(a b c))

- @person.errors.expects(:generate_message).with(:title, :inclusion, generate_message_options.merge(:value => 'z'))

- Person.validates_inclusion_of :title, validation_options.merge(:within => %w(a b c))

- @person.errors.expects(:generate_message).with(:title, :inclusion, generate_message_options.merge(:value => 'z'))

- Person.validates_exclusion_of :title, validation_options.merge(:in => %w(a b c))

- @person.errors.expects(:generate_message).with(:title, :exclusion, generate_message_options.merge(:value => 'a'))

- Person.validates_exclusion_of :title, validation_options.merge(:within => %w(a b c))

- @person.errors.expects(:generate_message).with(:title, :exclusion, generate_message_options.merge(:value => 'a'))

- @person.errors.expects(:generate_message).with(:title, :not_a_number, generate_message_options.merge(:value => 'a'))

- Person.validates_numericality_of :title, validation_options.merge(:only_integer => true)

- @person.errors.expects(:generate_message).with(:title, :not_an_integer, generate_message_options.merge(:value => '0.0'))

- Person.validates_numericality_of :title, validation_options.merge(:only_integer => true, :odd => true)

- @person.errors.expects(:generate_message).with(:title, :odd, generate_message_options.merge(:value => 0))

- Person.validates_numericality_of :title, validation_options.merge(:only_integer => true, :less_than => 0)

- @person.errors.expects(:generate_message).with(:title, :less_than, generate_message_options.merge(:value => 1, :count => 0))

- I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {attribute => {error_type => 'custom message'}}}}}}

- I18n.backend.store_translations 'en', :errors => {:messages => {error_type => 'global message'}}

- I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {attribute => {error_type => 'custom message with %{extra}'}}}}}}

- I18n.backend.store_translations 'en', :errors => {:messages => {error_type => 'global message'}}

- yield(@person, {:extra => "extra information"})

- I18n.backend.store_translations 'en', :errors => {:messages => {error_type => 'global message'}}

- Person.validates_acceptance_of :title, options_to_merge.merge(:allow_nil => false)

- Person.validates_length_of :title, options_to_merge.merge(:within => 3..5)

- Person.validates_length_of :title, options_to_merge.merge(:within => 3..5)

- Person.validates_length_of :title, options_to_merge.merge(:is => 5)

- Person.validates_format_of :title, options_to_merge.merge(:with => /\A[1-9][0-9]*\z/)

- Person.validates_inclusion_of :title, options_to_merge.merge(:in => %w(a b c))

- Person.validates_exclusion_of :title, options_to_merge.merge(:in => %w(a b c))

- Person.validates_numericality_of :title, options_to_merge.merge(:only_integer => true)

- Person.validates_numericality_of :title, options_to_merge.merge(:only_integer => true, :odd => true)

- Person.validates_numericality_of :title, options_to_merge.merge(:only_integer => true, :less_than => 0)

- I18n.backend.store_translations 'en', :errors => {:messages => {:custom_error => "I am a custom error"}}

- Person.validates_presence_of :title, :message => :custom_error

- I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:custom_error => "I am a custom error"}}}}}}

- Person.validates_presence_of :title, :message => :custom_error

- I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:custom_error => "I am a custom error"}}}}

- Person.validates_presence_of :title, :message => :custom_error

- Person.validates_presence_of :title, :message => "I am a custom error"

-

- Topic.validates_inclusion_of( :title, :in => 'aaa'..'bbb' )

- Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ) )

- assert_raise(ArgumentError) { Topic.validates_inclusion_of( :title, :in => nil ) }

- assert_raise(ArgumentError) { Topic.validates_inclusion_of( :title, :in => 0) }

- assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => "hi!" ) }

- assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => {} ) }

- assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => [] ) }

- Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ), :allow_nil => true )

- Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ), :message => "option %{value} is not in the list" )

- Topic.validates_inclusion_of( :title, :within => %w( a b c d e f g ) )

- Person.validates_inclusion_of :karma, :in => %w( abe monkey )

- Topic.validates_inclusion_of :title, :in => lambda{ |topic| topic.author_name == "sikachu" ? %w( monkey elephant ) : %w( abe wasabi ) }

- Person.validates_inclusion_of :karma, :in => :available_karmas

-

- Topic.validates_length_of( :title, :is => 5, :allow_nil => true )

- Topic.validates_length_of( :title, :is => 5, :allow_blank => true )

- Topic.validates_length_of :title, :minimum => 5

- Topic.validates_length_of :title, :maximum => 10

- Topic.validates_length_of :title, :minimum => 5, :allow_nil => true

- Topic.validates_length_of :title, :maximum => 5

- Topic.validates_length_of :title, :maximum => 5, :allow_nil => true

- Topic.validates_length_of(:title, :content, :within => 3..5)

- Topic.validates_length_of(:title, :within => 4...10)

- Topic.validates_length_of :title, :content, :within => 3..5, :allow_nil => true

- Topic.validates_length_of :title, :is => 5

- Topic.validates_length_of :title, :is => 5, :allow_nil => true

- Topic.validates_length_of :title, :is => bigmin + 5

- Topic.validates_length_of :title, :within => bigrange

- Topic.validates_length_of :title, :in => bigrange

- Topic.validates_length_of :title, :minimum => bigmin

- Topic.validates_length_of :title, :maximum => bigmax

- assert_raise(ArgumentError) { Topic.validates_length_of(:title, :is => -6) }

- assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within => 6) }

- assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum => "a") }

- assert_raise(ArgumentError) { Topic.validates_length_of(:title, :maximum => "a") }

- assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within => "a") }

- assert_raise(ArgumentError) { Topic.validates_length_of(:title, :is => "a") }

- Topic.validates_length_of( :title, :minimum => 5, :message => "boo %{count}" )

- Topic.validates_length_of( :title, :minimum => 5, :too_short => "hoo %{count}" )

- Topic.validates_length_of( :title, :maximum => 5, :message => "boo %{count}" )

- Topic.validates_length_of(:title, :in => 10..20, :message => "hoo %{count}")

- Topic.validates_length_of( :title, :maximum => 5, :too_long => "hoo %{count}" )

- Topic.validates_length_of :title, :minimum => 3, :maximum => 5, :too_short => 'too short', :too_long => 'too long'

- t = Topic.new(:title => 'a')

- t = Topic.new(:title => 'aaaaaa')

- Topic.validates_length_of( :title, :is => 5, :message => "boo %{count}" )

- Topic.validates_length_of( :title, :is => 5, :wrong_length => "hoo %{count}" )

- Topic.validates_length_of :title, :minimum => 5

- Topic.validates_length_of :title, :maximum => 5

- Topic.validates_length_of(:title, :content, :within => 3..5)

- Topic.validates_length_of :title, :within => 3..5, :allow_nil => true

- t = Topic.new(:title => "一二三四五")

- t = Topic.new(:title => "一二三")

- Topic.validates_length_of :title, :is => 5

- Topic.validates_length_of :content, :minimum => 5, :too_short => "Your essay must be at least %{count} words.",

- :tokenizer => lambda {|str| str.scan(/\w+/) }

- t = Topic.new(:content => "this content should be long enough")

- Topic.validates_length_of(:approved, :is => 4)

- t = Topic.new("title" => "uhohuhoh", "content" => "whatever", :approved => 1)

- t = Topic.new("title" => "uhohuhoh", "content" => "whatever", :approved => 1234)

- Person.validates_length_of :karma, :minimum => 5

- Topic.validates_length_of(:title, :within => 5..Float::INFINITY)

- Topic.validates_length_of(:author_name, :maximum => Float::INFINITY)

- Topic.validates_numericality_of :approved, :allow_nil => true

- Topic.validates_numericality_of :approved, :only_integer => true

- Topic.validates_numericality_of :approved, :only_integer => true, :allow_nil => true

- Topic.validates_numericality_of :approved, :greater_than => 10

- Topic.validates_numericality_of :approved, :greater_than_or_equal_to => 10

- Topic.validates_numericality_of :approved, :equal_to => 10

- Topic.validates_numericality_of :approved, :less_than => 10

- Topic.validates_numericality_of :approved, :less_than_or_equal_to => 10

- Topic.validates_numericality_of :approved, :odd => true

- Topic.validates_numericality_of :approved, :even => true

- Topic.validates_numericality_of :approved, :greater_than => 1, :less_than => 4, :even => true

- Topic.validates_numericality_of :approved, :other_than => 0

- Topic.validates_numericality_of :approved, :greater_than_or_equal_to => Proc.new {|topic| topic.min_approved }

- Topic.validates_numericality_of :approved, :less_than_or_equal_to => :max_approved

- Topic.validates_numericality_of :approved, :less_than => 4, :message => "smaller than %{count}"

- Topic.validates_numericality_of :approved, :greater_than => 4, :message => "greater than %{count}"

- Person.validates_numericality_of :karma, :allow_nil => false

- assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, :greater_than_or_equal_to => "foo" }

- assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, :less_than_or_equal_to => "foo" }

- assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, :greater_than => "foo" }

- assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, :less_than => "foo" }

- assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, :equal_to => "foo" }

- topic = Topic.new(:title => "numeric test", :content => "whatever")

- Person.validates_presence_of :karma, :message => "This string contains 'single' and \"double\" quotes"

- Person.validates :title, :presence => {:message => "" }

- Person.validates :title, :numericality => true

- Person.validates "title", :numericality => true

- Person.validates :salary, :numericality => { :message => 'my custom message' }

- Person.validates :karma, :email => true

- Person.validates :karma, :presence => true, :email => { :unless => :condition_is_true }

- Person.validates :karma, :presence => true, :email => true, :if => :condition_is_true

- Person.validates :karma, :presence => true, :email => true, :unless => :condition_is_true

- Person.validates :karma, :length => { :minimum => 20 }, :email => true, :allow_nil => true

- Person.validates :karma, :format => /positive|negative/

- Person.validates :gender, :inclusion => %w(m f)

- Person.validates :karma, :length => 6..20

- Person.validates :karma, :email => { :message => 'my custom message' }

- assert_raise(ArgumentError) { Person.validates :karma, :unknown => true }

- PersonWithValidator.validates :title, :presence => true

- PersonWithValidator.validates :title, :presence => { :custom => ' please' }

- # Shortcut for PersonWithValidator.validates :title, :like => { :with => "Mr." }

- PersonWithValidator.validates :title, :like => "Mr."

- Topic.validates :title, :confirmation => true, :message => 'Y U NO CONFIRM'

- test "with a class that adds errors on update and validating a new model with no arguments" do

- Topic.validates_with(ValidatorThatAddsErrors, :on => :create)

- assert topic.valid?, "Validation doesn't run on create if 'on' is set to update"

- Topic.validates_with(ValidatorThatAddsErrors, :on => :update)

- Topic.validates_with(ValidatorThatAddsErrors, :on => :create)

-end \ No newline at end of file

- test "vaidation with class that adds errors" do

- Topic.validates_with(ValidatorThatAddsErrors, :if => "1 == 2")

- Topic.validates_with(ValidatorThatAddsErrors, :if => "1 == 1")

- Topic.validates_with(ValidatorThatAddsErrors, :unless => "1 == 1")

- Topic.validates_with(ValidatorThatAddsErrors, :unless => "1 == 2")

- validator.expects(:new).with(:foo => :bar, :if => "1 == 1").returns(validator)

- Topic.validates_with(validator, :if => "1 == 1", :foo => :bar)

- assert topic.valid?

- end

-

- test "calls setup method of validator passing in self when validator has setup method" do

- topic = Topic.new

- validator = stub_everything

- validator.stubs(:new).returns(validator)

- validator.stubs(:validate)

- validator.stubs(:respond_to?).with(:setup).returns(true)

- validator.expects(:setup).with(Topic).once

- Topic.validates_with(validator)

- assert topic.valid?

- end

-

- test "doesn't call setup method of validator when validator has no setup method" do

- topic = Topic.new

- validator = stub_everything

- validator.stubs(:new).returns(validator)

- validator.stubs(:validate)

- validator.stubs(:respond_to?).with(:setup).returns(false)

- validator.expects(:setup).with(Topic).never

- Topic.validates_with(validator)

- Topic.validates_with(ValidatorThatValidatesOptions, :field => :first_name)

- Topic.validates_with(ValidatorPerEachAttribute, :attributes => [:title, :content])

- topic = Topic.new :title => "Title", :content => "Content"

- Topic.validates_with(ValidatorCheckValidity, :attributes => [:title])

- assert_raise RuntimeError do

- Topic.validates_with(ValidatorPerEachAttribute, :attributes => [:title, :content], :allow_nil => true)

- topic = Topic.new :content => ""

- Topic.validates_with(ValidatorPerEachAttribute, :attributes => [:title, :content], :allow_blank => true)

- topic = Topic.new :content => ""

- Topic.validates :title, :with => :my_validation

- topic = Topic.new :title => "foo"

- Topic.validates :title, :content, :with => :my_validation_with_arg

- topic = Topic.new :title => "foo"

- assert r.invalid?, "A reply without content shouldn't be saveable"

- assert r.valid?, "A reply with content should be saveable"

- assert_raise(NameError) do

- Topic.validates_length_of :title, :minimum => 2

- Topic.validates_length_of :title, :content, :minimum => 2

- t = Topic.new :title => ''

- def test_validaton_with_if_and_on

- Topic.validates_presence_of :title, :if => Proc.new{|x| x.author_name = "bad"; true }, :on => :update

- t = Topic.new(:title => "")

- Topic.validates_presence_of(:title, :message => proc { "no blanks here".upcase })

- Topic.validates_length_of :title, :minimum => 2

- Topic.validates_length_of :title, :minimum => 2

- Topic.validates_length_of :title, :minimum => 10