* If you have a change or new feature in mind, please [suggest it on the rubyonrails-core mailing list](https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core) and start writing code.

Rails Team

# ensure correct loading order

gem 'mocha', '~> 0.14', require: false

gem 'rack-cache', '~> 1.2'

gem 'jquery-rails', '~> 3.1.0'

gem 'turbolinks'

* Allow preview interceptors to be registered through

`config.action_mailer.preview_interceptors`.

#

mattr_accessor :preview_path, instance_writer: false

# :nodoc:

mattr_accessor :preview_interceptors, instance_writer: false

self.preview_interceptors = []

Base.preview_path

end

def inform_preview_interceptors(message) #:nodoc:

Base.preview_interceptors.each do |interceptor|

interceptor.previewing_email(message)

options.assets_dir ||= paths["public"].first

options.javascripts_dir ||= paths["public/javascripts"].first

options.stylesheets_dir ||= paths["public/stylesheets"].first

options.preview_path ||= defined?(Rails.root) ? "#{Rails.root}/test/mailers/previews" : nil

end

register_observers(options.delete(:observers))

options.each { |k,v| send("#{k}=", v) }

end

end

FIXTURE_LOAD_PATH = File.expand_path('fixtures', File.dirname(__FILE__))

ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH

end

end

def test_asset_host_as_one_argument_proc

AssetHostMailer.config.asset_host = Proc.new { |source|

if source.starts_with?('/images')

end

}

mail = AssetHostMailer.email_with_asset

assert_equal %Q{<img alt="Somelogo" src="http://images.example.com/images/somelogo.png" />}, mail.body.to_s.strip

end

end

end

test "delivery method can be customized per instance" do

email = DeliveryMailer.welcome.deliver

assert_instance_of Mail::SMTP, email.delivery_method

email = DeliveryMailer.welcome(delivery_method: :test).deliver

test "delivery method can be customized in subclasses not changing the parent" do

DeliveryMailer.delivery_method = :test

assert_equal :smtp, ActionMailer::Base.delivery_method

email = DeliveryMailer.welcome.deliver

assert_instance_of Mail::TestMailer, email.delivery_method

end

get ':controller(/:action(/:id))'

end

def app

end

teardown do

end

def test_send_mail

with_translation 'de', email_subject: '[Anmeldung] Willkommen' do

get '/test/send_mail'

assert_equal "Mail sent - Subject: [Anmeldung] Willkommen", @response.body

require 'abstract_unit'

class TestHelperMailer < ActionMailer::Base

assert_equal "UTF-8", charset

end

def test_assert_emails

assert_nothing_raised do

assert_emails 1 do

* Add `config.action_controller.always_permitted_parameters` to configure which

parameters are permitted globally. The default value of this configuration is

`['controller', 'action']`.

application. Use of a symbol should be replaced with `action: symbol`.

Use of a string without a "#" should be replaced with `controller: string`.

* Fix URL generation with `:trailing_slash` such that it does not add

a trailing slash after `.:format`

*Tony Wooster*

Please check [4-1-stable](https://github.com/rails/rails/blob/4-1-stable/actionpack/CHANGELOG.md) for previous changes.

s.add_dependency 'activesupport', version

s.add_dependency 'rack-test', '~> 0.6.2'

s.add_dependency 'actionview', version

# pairs by the standardized `:`, `;`, or `\t` delimiters defined in

# `AUTHN_PAIR_DELIMITERS`.

def raw_params(auth)

end

# Encodes the given token and options into an Authorization header value.

json = json.to_json(options) unless json.kind_of?(String)

if options[:callback].present?

else

self.content_type ||= Mime::JSON

json

options[:html] = ERB::Util.html_escape(options[:html])

end

end

if options[:status]

end

end

# Process controller specific options, as status, content-type and location.

def _process_options(options) #:nodoc:

status, content_type, location = options.values_at(:status, :content_type, :location)

end

@_subscribers << ActiveSupport::Notifications.subscribe("!render_template.action_view") do |_name, _start, _finish, _id, payload|

end

end

end

@formats = nil

@env.delete_if { |k, v| k =~ /^(action_dispatch|rack)\.request/ }

@env.delete_if { |k, v| k =~ /^action_dispatch\.rescue/ }

@method = @request_method = nil

@fullpath = @ip = @remote_ip = @protocol = nil

@env['action_dispatch.request.query_parameters'] = {}

end

def formats

Array(Mime[parameters[:format]])

elsif use_accept_header && valid_accept_header

accepts

else

[Mime::HTML]

end

end

# Sets the \variant for template.

def variant=(variant)

if variant.is_a?(Symbol)

require 'active_support/core_ext/hash/keys'

require 'active_support/core_ext/hash/indifferent_access'

module ActionDispatch

module Http

@env[PARAMETERS_KEY] = parameters

end

def symbolized_path_parameters

path_parameters

end

# Returned hash keys are strings:

#

# {'action' => 'my_action', 'controller' => 'my_controller'}

def path_parameters

@env[PARAMETERS_KEY] ||= {}

end

private

#

def normalize_encode_params(params)

case params

when Hash

if params.has_key?(:tempfile)

UploadedFile.new(params)

else

params.each_with_object({}) do |(key, val), new_hash|

val.map! { |el| normalize_encode_params(el) }

else

normalize_encode_params(val)

end

# Returns true if the "X-Requested-With" header contains "XMLHttpRequest"

def xml_http_request?

@env['HTTP_X_REQUESTED_WITH'] =~ /XMLHttpRequest/i

end

# http://tools.ietf.org/html/rfc3986

class UriEncoder # :nodoc:

ENCODE = "%%%02X".freeze

ALPHA = "a-zA-Z".freeze

DIGIT = "0-9".freeze

end

def unescape_uri(uri)

end

protected

def escape(component, pattern)

end

def percent_encode(unsafe)

end

end

def []=(name, options)

if options.is_a?(Hash)

options.symbolize_keys!

options = { :value => @verifier.generate(serialize(name, options)) }

end

@parent_jar[name] = options

end

options[:value] = @encryptor.encrypt_and_sign(serialize(name, options[:value]))

@parent_jar[name] = options

end

end

end

# to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create

# action that sets <tt>flash[:notice] = "Post successfully created"</tt> before redirecting to a display action that can

# then expose the flash to its template. Actually, that exposure is automatically done.

# flash.alert = "You must be logged in"

# flash.notice = "Post successfully created"

#

#

# See docs on the FlashHash class for more details about the flash.

class Flash

# reasonably sure that your upgrade is otherwise complete. Additionally,

# you should take care to make sure you are not relying on the ability to

# decode signed cookies generated by your app in external applications or

#

# Note that changing the secret key will invalidate all existing sessions!

class CookieStore < Rack::Session::Abstract::ID

end

with_scope_level(:nested) do

shallow_scope(parent_resource.nested_scope, nested_options) { yield }

else

scope(parent_resource.nested_scope, nested_options) { yield }

# This makes app.url_for and app.foo_path available in the console

if app.respond_to?(:routes)

singleton_class.class_eval do

end

end

end

def action=(action_name)

end

def if_modified_since=(last_modified)

assert_equal(expected, actual)

end

test "token_and_options returns nil with no value after the equal sign" do

actual = ActionController::HttpAuthentication::Token.token_and_options(malformed_request).first

expected = nil

assert_equal(expected, actual)

end

private

end

def malformed_request

end

end

def iphone_with_html_response_type

request.format = :iphone if request.env["HTTP_ACCEPT"] == "text/iphone"

assert_equal '<html><div id="html">HTML for all_types_with_layout</div></html>', @response.body

end

def test_xhr

xhr :get, :js_or_html

assert_equal 'JS', @response.body

assert_status 404

end

get "/render_body/with_layout/with_nil"

assert_status 200

end

get "/render_body/with_layout/with_nil_and_status"

assert_status 403

end

assert_status 404

end

get "/render_html/with_layout/with_nil"

assert_status 200

end

get "/render_html/with_layout/with_nil_and_status"

assert_status 403

end

assert_status 404

end

get "/render_plain/with_layout/with_nil"

assert_status 200

end

get "/render_plain/with_layout/with_nil_and_status"

assert_status 403

end

assert_status 404

end

get "/render_text/with_layout/with_nil"

assert_status 200

end

get "/render_text/with_layout/with_nil_and_status"

assert_status 403

end

def test_render_json_with_callback

xhr :get, :render_json_hello_world_with_callback

assert_equal 'text/javascript', @response.content_type

end

assert_equal "baz", @request.filtered_parameters[:foo]

end

get :test_params, :id => "foo"

@request.recycle!

get :test_params

end

def test_request_protocol_is_reset_after_request

mount SprocketsApp, :at => "/", :via => :get

end

def app

end

def test_app_name_is_properly_generated_when_engine_is_mounted_in_resources

end

def parse

self.class.last_parameters = request.parameters

head :ok

end

assert_not request.format.json?

end

test "formats with xhr request" do

request = stub_request 'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"

request.expects(:parameters).at_least_once.returns({})

assert_equal({"bar" => 2}, request.query_parameters)

end

request = stub_request("QUERY_STRING" => "x[y]=1&x[y][][w]=2")

end

end

test "we have access to the original exception" do

end

end

test "setting variant" do

request = stub_request

end

include Routes.url_helpers

def test_accessing_concern_from_resources

get "/posts/1/comments"

assert_equal '/blogs/1/posts/2/comments/new', new_blog_post_comment_path(:blog_id => 1, :post_id => 2)

end

def test_shallow_nested_resources_within_scope

draw do

scope '/hello' do

end

end

draw do

scope '/countries/:country', :constraints => lambda { |params, req| %w(all France).include?(params[:country]) } do

get '/', :to => 'countries#index'

get '/downloads/1/1.tar'

assert_equal 'downloads#show', @response.body

assert_equal '/downloads/1/1.tar', download_path('1')

assert_equal '/downloads/1/1.tar', download_path('1', '1')

end

def draw(&block)

self.class.stub_controllers do |routes|

end

end

def url_for(options = {})

end

def method_missing(method, *args, &block)

if method.to_s =~ /_(path|url)$/

else

super

end

get "/" => TestAltApp::AltApp.new

end

def app

end

def test_alt_request_without_header

def setup

super

s = self

get '/hello' => s.simple_app('fail')

get '/goodbye' => s.simple_app('goodbye')

end

get '/hello' => s.simple_app('hello')

end

end

def test_goodbye_should_be_available

end

def draw(&block)

end

def test_missing_controller

resources :posts

end

def app

end

include DefaultScopeRoutes.url_helpers

lambda { |env| [ 200, { 'Content-Type' => 'text/plain' }, [response] ] }

end

s = self

(RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC4791 + RFC5789).each do |method|

match '/' => s.simple_app(method), :via => method.underscore.to_sym

end

end

include Routes.url_helpers

test 'escapes slash in generated path segment' do

assert_equal '/a%20b%2Fc+d', segment_path(:segment => 'a b/c+d')

end

include Routes.url_helpers

test 'recognizes unicode path' do

get "/#{Rack::Utils.escape("ほげ")}"

end

include Routes.url_helpers

test "controller option which starts with '/' from multiple nested controller" do

get "/foo/bar/baz"

end

include Routes.url_helpers

test 'recognizes tilde path' do

get "/~user"

end

end

test "redirect escapes interpolated parameters with redirect proc" do

get "/foo/1%3E"

end

end

test "parameters are reset between constraint checks" do

get "/bar"

end

#include Routes.url_helpers

def test_glob_constraint

get "/dummy"

end

include Routes.url_helpers

test 'enabled when not mounted and default_url_options is empty' do

assert Routes.url_helpers.optimize_routes_generation?

end

end

include Routes.url_helpers

end

include Routes.url_helpers

test "constraints are copied to defaults when using constraints method" do

assert_equal 'http://admin.example.com/', admin_root_url

end

end

def app

end

include Routes.url_helpers

end

include Routes.url_helpers

def test_integer_port_constraints

get 'http://www.example.com/integer'

end

include Routes.url_helpers

def test_string_format_constraints

get 'http://www.example.com/string'

end

end

def app

end

include Routes.url_helpers

end

end

def app

end

include Routes.url_helpers

end

end

def app

end

include Routes.url_helpers

end

end

include Routes.url_helpers

mount MyRouteGeneratingController.action(:index), at: '/bar'

end

def _routes

Routes

end

def app

end

test "generating URLS normally" do

require 'abstract_unit'

module ActionDispatch

assert_equal "a/b c+d", Utils.unescape_uri("a%2Fb%20c+d")

end

def test_normalize_path_not_greedy

assert_equal "/foo%20bar%20baz", Utils.normalize_path("/foo%20bar%20baz")

end

* Added String support for min and max properties for date field helpers.

*Todd Bealmear*

* Remove wrapping div with inline styles for hidden form fields.

We are dropping HTML 4.01 and XHTML strict compliance since input tags directly

for Content Security Policy.

*Joost Baaij*

== Dependency on Active Record and database setup

Test cases in the test/activerecord/ directory depend on having

these tests are skipped.

Other tests are runnable from a fresh copy of actionview without any configuration.

end

end

# If the +source+ filename has no extension, .js will be appended (except for explicit URIs)

# Full paths from the document root will be passed through.

# Used internally by +javascript_include_tag+ to build the script path.

end

alias_method :path_to_javascript, :javascript_path # aliased to avoid conflicts with a javascript_path named route

# This will use +javascript_path+ internally, so most of their behaviors will be the same.

def javascript_url(source, options = {})

url_to_asset(source, {type: :javascript}.merge!(options))

module TagHelper

extend ActiveSupport::Concern

include CaptureHelper

BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked autobuffer

autoplay controls loop selected hidden scoped async

def test_render_text_with_nil

get :render_text_with_nil

assert_response 200

end

# :ported:

def test_rendering_nothing_on_layout

get :rendering_nothing_on_layout

end

def test_render_to_string_doesnt_break_assigns

end

end

def load_schema

File.read(File.dirname(__FILE__) + "/fixtures/db_definitions/sqlite.sql").split(';').each do |sql|

ActiveRecord::Base.connection.execute(sql) unless sql.blank?

def test_html_escape_once

assert_equal '1 &lt;&gt;&amp;&quot;&#39; 2 &amp; 3', html_escape_once('1 <>&"\' 2 &amp; 3')

end

def test_html_escape_once_returns_unsafe_strings_when_passed_unsafe_strings

def test_escape_once

assert_equal '1 &lt; 2 &amp; 3', escape_once('1 < 2 &amp; 3')

end

def test_tag_honors_html_safe_for_param_values

module Naming

def self.extended(base) #:nodoc:

base.class_eval do

delegate :model_name, to: :class

end

end

include InstanceMethodsOnActivation

if options.fetch(:validations, true)

# This ensures the model has a password by checking whether the password_digest

# is present, so that this works with both new and existing records. However,

# when there is an error, the message is added to the password attribute instead

ActiveModel::SecurePassword.min_cost = @original_min_cost

end

end

test "create a new user with validations and valid password/confirmation" do

class User

extend ActiveModel::Callbacks

include ActiveModel::SecurePassword

define_model_callbacks :create

class Visitor

extend ActiveModel::Callbacks

include ActiveModel::SecurePassword

define_model_callbacks :create

* PostgreSQL renaming table doesn't attempt to rename non existent sequences.

*Abdelkader Boudih*

Serialized attributes on ActiveRecord models will no longer save when

unchanged. Fixes #8328.

* Pluck now works when selecting columns from different tables with the same

name.

*Vilius Luneckas* *Ahmed AbouElhamayed*

* `before_add` callbacks are fired before the record is saved on

associations. Before this change, `before_add` callbacks would be fired

before the record was saved on `has_and_belongs_to_many` associations, but

*not* on `has_many :through` associations.

# that is the inverse of this <tt>has_one</tt> association. Does not work in combination

# with <tt>:through</tt> or <tt>:as</tt> options.

# See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.

#

# Option examples:

# has_one :credit_card, dependent: :destroy # destroys the associated credit card

# has_one :boss, readonly: :true

# has_one :club, through: :membership

# has_one :primary_address, -> { where primary: true }, through: :addressables, source: :addressable

def has_one(name, scope = nil, options = {})

reflection = Builder::HasOne.build(self, name, scope, options)

Reflection.add_reflection self, name, reflection

# object that is the inverse of this <tt>belongs_to</tt> association. Does not work in

# combination with the <tt>:polymorphic</tt> options.

# See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.

#

# Option examples:

# belongs_to :firm, foreign_key: "client_of"

# belongs_to :post, counter_cache: true

# belongs_to :company, touch: true

# belongs_to :company, touch: :employees_last_updated_at

def belongs_to(name, scope = nil, options = {})

reflection = Builder::BelongsTo.build(self, name, scope, options)

Reflection.add_reflection self, name, reflection

reflection = builder.build(model)

define_accessors model, reflection

define_callbacks model, reflection

builder.define_extensions model

reflection

end

CODE

end

def self.valid_dependent_options

raise NotImplementedError

end

module ActiveRecord::Associations::Builder

class SingularAssociation < Association #:nodoc:

def valid_options

end

def self.define_accessors(model, reflection)

end

CODE

end

end

end

super

end

protected

attr_reader :attributes

# This works for mysql and mysql2 where table.column can be used to

# resolve ambiguity.

#

# the column name (as per syntax requirements).

def quote_table_name_for_assignment(table, attr)

quote_table_name("#{table}.#{attr}")

# Make MySQL reject illegal values rather than truncating or blanking them, see

# http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html#sqlmode_strict_all_tables

# If the user has provided another value for sql_mode, don't replace it.

end

# NAMES does not have an equals sign, see

module ActiveRecord

module ConnectionAdapters

# PostgreSQL-specific extensions to column definitions in a table.

class PostgreSQLColumn < Column #:nodoc:

attr_accessor :array

def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil)

require 'active_record/connection_adapters/postgresql/oid/time'

require 'active_record/connection_adapters/postgresql/oid/uuid'

require 'active_record/connection_adapters/postgresql/oid/vector'

require 'active_record/connection_adapters/postgresql/oid/type_map_initializer'

def cast_value(value)

case value

when 'Infinity' then ::Float::INFINITY

when '-Infinity' then -::Float::INFINITY

when 'NaN' then ::Float::NAN

end

def type_cast_from_database(value)

end

def type_cast_for_database(value)

end

def accessor

ActiveRecord::Store::StringKeyedHashAccessor

end

end

end

end

@type = type

end

def type_cast_for_schema(value)

value.inspect.gsub('Infinity', '::Float::INFINITY')

end

def cast_value(value)

return if value == 'empty'

return value if value.is_a?(::Range)

end

::Range.new(from, to, extracted[:exclude_end])

end

end

end

end

def initialize(type)

@type = type

end

end

end

end

sql_type = type_to_sql(column.type, column.limit, column.precision, column.scale)

case value

when Float

"'#{value.to_s}'"

else

super

end

when String

case sql_type

when /^bit/

case value

end

else

super

end

end

# Quotes strings for use in SQL input.

def quote_string(s) #:nodoc:

@connection.escape(s)

private

def _quote(value)

"'#{escape_bytea(value.to_s)}'"

else

super

end

end

def _type_cast(value)

# Return a bind param hash with format as binary.

# See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc

# for more information

{ value: value.to_s, format: 1 }

else

super

end

m.register_type 'cidr', OID::Cidr.new

m.register_type 'inet', OID::Inet.new

m.register_type 'uuid', OID::Uuid.new

m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)

m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)

m.register_type 'citext', OID::SpecializedString.new(:citext)

end

def exec_no_cache(sql, name, binds)

end

def exec_cache(sql, name, binds)

raise ArgumentError, "No database file specified. Missing argument: database"

end

if ':memory:' != config[:database]

config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)

dirname = File.dirname(config[:database])

##

def initialize_dup(other) # :nodoc:

@attributes = @attributes.dup

run_callbacks(:initialize) unless _initialize_callbacks.empty?

end

def init_internals

@aggregation_cache = {}

@association_cache = {}

counter_name = reflection.counter_cache_column

stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({

}, primary_key)

connection.update stmt

end

# the companies table with type = "Firm". You can then fetch this row again using

# <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.

#

# subclass will instantly be marked as dirty and the type column will be included

# STI classes:

#

# Company.new.changed? # => false

#

# If you don't have a type column defined in your table, single-table inheritance won't

# be triggered. In that case, it'll work just like normal subclasses with no special magic

# This class is used to verify that all migrations have been run before

# loading a web page if config.active_record.migration_error is set to :page_load

class CheckPending

@app = app

@last_check = 0

end

def call(env)

mtime = ActiveRecord::Migrator.last_migration.mtime.to_i

if @last_check < mtime

@last_check = mtime

end

end

@app.call(env)

end

end

class << self

end

@attributes = fresh_object.instance_variable_get('@attributes')

self

end

end

def call(env)

connection_id = ActiveRecord::Base.connection_id

response = @app.call(env)

response[2] = Rack::BodyProxy.new(response[2]) do

# # => counts the number of different age values

#

# Note: not all valid +select+ expressions are valid +count+ expressions. The specifics differ

def count(column_name = nil, options = {})

# TODO: Remove options argument as soon we remove support to

# activerecord-deprecated_finders.

when :ruby

file ||= File.join(db_dir, "schema.rb")

check_schema_file(file)

load(file)

when :sql

file ||= File.join(db_dir, "structure.sql")

check_schema_file(file)

structure_load(current_config, file)

else

raise ArgumentError, "unknown format #{format.inspect}"

FileUtils.rm(file) if File.exist?(file)

end

def charset

connection.encoding

class Data # :nodoc:

def initialize(value)

end

def to_s

:string

end

def changed_in_place?(raw_old_value, new_value)

if new_value.is_a?(::String)

raw_old_value != new_value

end

def type_cast_for_database(value)

end

end

# These predicates are not documented, as I need to look further into

# their use, and see if they can be removed entirely.

def number? # :nodoc:

false

end

column = klass.columns_hash[attribute_name]

value = klass.connection.type_cast(value, column)

# will use SQL LOWER function before comparison, unless it detects a case insensitive collation

klass.connection.case_insensitive_comparison(table, attribute, column, value)

else

assert_equal "1", attributes["published"]

assert_equal 1, @connection.type_cast(true, boolean_column)

end

test "test type casting without emulated booleans" do

assert_equal "1", attributes["published"]

assert_equal 1, @connection.type_cast(true, boolean_column)

end

test "with booleans stored as 1 and 0" do

assert_equal :string, @column.type

assert_equal "character varying", @column.sql_type

assert @column.array

assert_not @column.number?

assert_not @column.binary?

column = PostgresqlBitString.columns_hash["a_bit"]

assert_equal :bit, column.type

assert_equal "bit(8)", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

column = PostgresqlBitString.columns_hash["a_bit_varying"]

assert_equal :bit_varying, column.type

assert_equal "bit varying(4)", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

column = Citext.columns_hash['cival']

assert_equal :citext, column.type

assert_equal 'citext', column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

assert_nil column.type

assert_equal "full_address", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :full_address, column.type

assert_equal "full_address", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :decimal, column.type

assert_equal "custom_money", column.sql_type

assert column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :enum, column.type

assert_equal "mood", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :tsvector, column.type

assert_equal "tsvector", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

column = PostgresqlPoint.columns_hash["x"]

assert_equal :point, column.type

assert_equal "point", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

assert_equal :hstore, @column.type

assert_equal "hstore", @column.sql_type

assert_not @column.number?

assert_not @column.binary?

assert_not @column.array

end

end

def test_type_cast_hstore

assert_equal({}, @column.type_cast_from_database(""))

assert_equal({'key'=>nil}, @column.type_cast_from_database('key => NULL'))

assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast_from_database(%q(c=>"}", "\"a\""=>"b \"a b")))

end

def test_gen1

end

def test_gen2

end

def test_gen3

end

def test_gen4

end

def test_parse1

assert_equal :json, column.type

assert_equal "json", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :ltree, column.type

assert_equal "ltree", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal "money", column.sql_type

assert_equal 2, column.scale

assert column.number?

assert_not column.binary?

assert_not column.array

end

money.reload

assert_equal new_value, money.wealth

end

end

assert_equal :cidr, column.type

assert_equal "cidr", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :inet, column.type

assert_equal "inet", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal :macaddr, column.type

assert_equal "macaddr", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

assert_equal "'1970-01-01 00:00:00.000000'", @conn.quote(Time.at(0))

assert_equal "'1970-01-01 00:00:00.000000'", @conn.quote(Time.at(0).to_datetime)

end

end

end

end

assert_raises(ArgumentError) { PostgresqlRange.create!(float_range: "(0.5, 0.7]") }

end

private

def assert_equal_round_trip(range, attribute, value)

round_trip(range, attribute, value)

assert_equal :uuid, column.type

assert_equal "uuid", column.sql_type

assert_not column.number?

assert_not column.binary?

assert_not column.array

end

begin

@connection.transaction do

@connection.create_table('xml_data_type') do |t|

end

end

rescue ActiveRecord::StatementInvalid

@connection.execute %q|insert into xml_data_type (payload) VALUES(null)|

assert_nil XmlDataType.first.payload

end

end

end

end

def test_invalid_column

assert @conn.valid_type?(:foobar)

end

end

end

class BelongsToWithForeignKeyTest < ActiveRecord::TestCase

def test_destroy_linked_models

address = AuthorAddress.create!

author = Author.create! name: "Author", author_address_id: address.id

author.destroy!

end

end

end

def test_has_many_through_has_one_with_has_many_through_source_reflection_preload

members = assert_queries(4) { Member.includes(:organization_member_details).to_a.sort_by(&:id) }

groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)

class ::SpecialTopic < ::Topic

has_many :special_replies, :foreign_key => 'parent_id'

end

class ::SpecialReply < ::Reply

end

assert_equal "'Topic' has no association called 'undefined_count'", e.message

end

end

ensure

Topic.default_scopes = prev_default_scopes

end

end

end

super

@connection = MiniTest::Mock.new

@app = MiniTest::Mock.new

@pending.instance_variable_set :@last_check, -1 # Force checking

end

def teardown

assert @connection.verify

assert @app.verify

end

def test_errors_if_pending

require 'rexml/document'

class PersistenceTest < ActiveRecord::TestCase

# Oracle UPDATE does not support ORDER BY

unless current_adapter?(:OracleAdapter)

assert_equal 1, post[:wibble]

assert_nil post.reload[:wibble]

end

end

assert_equal 'product_categories', reflection.join_table

end

private

def assert_reflection(klass, association, options)

assert reflection = klass.reflect_on_association(association)

require 'models/comment'

require 'models/edge'

require 'models/topic'

module ActiveRecord

class WhereTest < ActiveRecord::TestCase

def test_where_copies_bind_params

author = authors(:david)

assert_equal 4, Edge.where(blank).order("sink_id").to_a.size

end

end

end

end

create_table :author_addresses, force: true do |t|

end

create_table :author_favorites, force: true do |t|

t.column :author_id, :integer

* Add `Hash#transform_values` to simplify a common pattern where the values of a

hash must change, but the keys are left the same.

# Procs:: A proc to call with the object.

# Objects:: An object with a <tt>before_foo</tt> method on it to call.

#

def make_lambda(filter)

case filter

when Symbol

#

# set_callback :save, :before, :before_meth

# set_callback :save, :after, :after_meth, if: :condition

#

# The second arguments indicates whether the callback is to be run +:before+,

# +:after+, or +:around+ the event. If omitted, +:before+ is assumed. This

civil(year, month, day, hour, min, sec, offset)

end

def to_f

end

# Converts +self+ to an integer number of seconds since the Unix epoch.

HTML_ESCAPE = { '&' => '&amp;', '>' => '&gt;', '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }

JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003e', '<' => '\u003c', "\u2028" => '\u2028', "\u2029" => '\u2029' }

HTML_ESCAPE_REGEXP = /[&"'><]/

JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u

# A utility method for escaping HTML tag characters.

def test_to_f

assert_equal 946684800.0, DateTime.civil(2000).to_f

assert_equal 946684800.0, DateTime.civil(1999,12,31,19,0,0,Rational(-5,24)).to_f

end

def test_to_i

FileUtils.mkdir_p(CACHE_DIR)

Downloader.download(UNIDATA_URL + UNIDATA_FILE, CACHE_DIR + UNIDATA_FILE)

@proxy = ActiveSupport::Multibyte::Chars

end

def test_normalizations_C

def inspect_codepoints(str)

str.to_s.unpack("U*").map{|cp| cp.to_s(16) }.join(' ')

end

File.write('Gemfile', <<-GEMFILE)

source 'https://rubygems.org'

gem 'rails', github: 'rails/rails'

GEMFILE

system 'bundle'

This can be configured using the `preview_path` option.

See its

for a detailed write up.

### Active Record enums

Railties

--------

### Removals

* The `rails application` command has been removed without replacement.

([Pull Request](https://github.com/rails/rails/pull/11616))

### Notable changes

* Introduced `bin/setup` script to bootstrap an application.

([Pull Request](https://github.com/rails/rails/pull/15189))

* Introduced `Rails.gem_version` as a convenience method to return `Gem::Version.new(Rails.version)`.

([Pull Request](https://github.com/rails/rails/pull/14101))

Action Pack

-----------

### Deprecations

* Deprecated support for setting the `:to` option of a router to a symbol or a

string that does not contain a `#` character:

### Notable changes

* The `*_filter` family methods has been removed from the documentation. Their

usage are discouraged in favor of the `*_action` family methods:

* Added HTTP method `MKCALENDAR` from RFC-4791

([Pull Request](https://github.com/rails/rails/pull/15121))

Action View

-------------

### Deprecations

### Notable changes

Action Mailer

-------------

### Notable changes

Active Record

-------------

### Removals

* Removed deprecated method `ActiveRecord::Base.quoted_locking_column`.

([Pull Request](https://github.com/rails/rails/pull/15612))

`proper_table_name` instance method on `ActiveRecord::Migration` instead.

([Pull Request](https://github.com/rails/rails/pull/15512))

* Removed unused `:timestamp` type. Transparently alias it to `:datetime`

in all cases. Fixes inconsistencies when column types are sent outside of

`ActiveRecord`, such as for XML Serialization.

### Deprecations

* Deprecated `serialized_attributes` without replacement.

([Pull Request](https://github.com/rails/rails/pull/15704))

* Deprecated using `.joins`, `.preload` and `.eager_load` with associations that

depends on the instance state (i.e. those defined with a scope that takes an

argument) without replacement.

is not fully possible because the Ruby range does not support excluded

beginnings.

([Commit](https://github.com/rails/rails/commit/91949e48cf41af9f3e4ffba3e5eecf9b0a08bfc3))

### Notable changes

* Added support for `#pretty_print` in `ActiveRecord::Base` objects.

([Pull Request](https://github.com/rails/rails/pull/15172))

* Added support for user-created range types in PostgreSQL adapter.

([Commit](https://github.com/rails/rails/commit/4cb47167e747e8f9dc12b0ddaf82bdb68c03e032))

Active Model

------------

### Removals

### Notable changes

* Introduced `#validate` as an alias for `#valid?`.

([Pull Request](https://github.com/rails/rails/pull/14456))

Active Support

--------------

### Removals

### Notable changes

* The `humanize` inflector helper now strips any leading underscores.

([Commit](https://github.com/rails/rails/commit/daaa21bc7d20f2e4ff451637423a25ff2d5e75c7))

* Introduce `Concern#class_methods` as an alternative to `module ClassMethods`,

as well as `Kernel#concern` to avoid the `module Foo; extend ActiveSupport::Concern; end`

boilerplate. ([Commit](https://github.com/rails/rails/commit/b16c36e688970df2f96f793a759365b248b582ad))

Credits

-------

[full list of contributors to Rails](http://contributors.rubyonrails.org/) for

the many people who spent many hours making Rails, the stable and robust

framework it is. Kudos to all of them.

</p>

<% else %>

<p>

These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together.

</p>

<% end %>

<p>

</p>

person.token = nil

person.valid? # => raises ActiveModel::StrictValidationFailed

```

The Object Life Cycle

---------------------

Callbacks allow you to trigger logic before or after an alteration of an object's state.

```ruby

class Computer < ActiveRecord::Base

validates :mouse, presence: true,

unless: Proc.new { |c| c.trackpad.present? }

end

```

The easiest way to add custom validators for validating individual attributes

is with the convenient `ActiveModel::EachValidator`. In this case, the custom

validator class must implement a `validate_each` method which takes three

instance.

```ruby

#### Safe Strings

```ruby

"".html_safe? # => false

#### `Time.current`

#### `all_day`, `all_week`, `all_month`, `all_quarter` and `all_year`

English

-------

Example Code

------------

The query string strategy has several disadvantages:

1. **Not all caches will reliably cache content where the filename only differs by

[Steve Souders recommends](http://www.stevesouders.com/blog/2008/08/23/revving-filenames-dont-use-querystring/),

"...avoiding a querystring for cacheable resources". He found that in this

case 5-20% of requests will not be cached. Query strings in particular do not

work at all with some CDNs for cache invalidation.

The default query string in Rails 2.x is based on the modification time of

the files. When assets are deployed to a cluster, there is no guarantee that the

timestamps will be the same, resulting in different values being used depending

on which server handles the request.

When static assets are deployed with each new release of code, the mtime

(time of last modification) of _all_ these files changes, forcing all remote

clients to fetch them again, even when the content of those assets has not changed.

##### `:as`

##### `:autosave`

##### `:through`

##### `:validate`

##### `:as`

##### `:autosave`

##### `:through`

##### `:validate`

##### `extending`

##### `group`

##### `extending`

##### `group`

Cache Stores

------------

TIP: Page caches are always stored on disk.

$ cd commandsapp

$ bin/rails server

=> Booting WEBrick

=> Call with -d to detach

=> Ctrl-C to shutdown server

[2013-08-07 02:00:01] INFO WEBrick 1.3.1

```bash

$ bin/rails console --sandbox

Any modifications you make will be rolled back on exit

irb(main):001:0>

```

Ruby version 1.9.3 (x86_64-linux)

RubyGems version 1.3.6

Rack version 1.3

JavaScript Runtime Node.js (V8)

Middleware Rack::Sendfile, ActionDispatch::Static, Rack::Lock, #<ActiveSupport::Cache::Strategy::LocalCache::Middleware:0x007ffd131a7c88>, Rack::Runtime, Rack::MethodOverride, ActionDispatch::RequestId, Rails::Rack::Logger, ActionDispatch::ShowExceptions, ActionDispatch::DebugExceptions, ActionDispatch::RemoteIp, ActionDispatch::Reloader, ActionDispatch::Callbacks, ActiveRecord::Migration::CheckPending, ActiveRecord::ConnectionAdapters::ConnectionManagement, ActiveRecord::QueryCache, ActionDispatch::Cookies, ActionDispatch::Session::CookieStore, ActionDispatch::Flash, ActionDispatch::ParamsParser, Rack::Head, Rack::ConditionalGet, Rack::ETag

Application root /home/foobar/commandsapp

Environment development

config.action_mailer.interceptors = ["MailInterceptor"]

```

### Configuring Active Support

There are a few configuration options available in Active Support:

Once you're happy that the pull request contains a good change, comment on the GitHub issue indicating your approval. Your comment should indicate that you like the change and what you like about it. Something like:

If your comment simply says "+1", then odds are that other reviewers aren't going to take it too seriously. Show that you took the time to review the pull request.

```bash

=> Booting WEBrick

=> Run `rails server -h` for more startup options

=> Notice: server is listening on all interfaces (0.0.0.0). Consider using 127.0.0.1 (--binding option)

=> Ctrl-C to shutdown server

--> #0 ArticlesController.index

at /PathTo/project/test_app/app/controllers/articles_controller.rb:8

#1 ActionController::ImplicitRender.send_action(method#String, *args#Array)

#2 AbstractController::Base.process_action(action#NilClass, *args#Array)

#3 ActionController::Rendering.process_action(action#NilClass, *args#NilClass)

...

```

```

(byebug) frame 2

184: # is the intended way to override action dispatching.

185: #

186: # Notice that the first argument is the method to be dispatched

```

(byebug) step

50: ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])

51: end

52: alias :day :days

directory structure, and are both generated using the `rails plugin new`

generator. The difference is that an engine is considered a "full plugin" by

Rails (as indicated by the `--full` option that's passed to the generator

engine will provide blogging functionality to its host applications, allowing

for new articles and comments to be created. At the beginning of this guide, you

will be working solely within the engine itself, but in later sections you'll

It's important to keep in mind at all times that the application should

**always** take precedence over its engines. An application is the object that

To see demonstrations of other engines, check out

[Devise](https://github.com/plataformatec/devise), an engine that provides

class.

To keep it simple in this case, the application will have a class called `User`

```bash

rails g model user name:string

Looking at this output, it's easy to understand how generators work in Rails 3.0 and above. The scaffold generator doesn't actually generate anything, it just invokes others to do the work. This allows us to add/replace/remove any of those invocations. For instance, the scaffold generator invokes the scaffold_controller generator, which invokes erb, test_unit and helper generators. Since each generator has a single responsibility, they are easy to reuse, avoiding code duplication.

```ruby

config.generators do |g|

end

```

To demonstrate this, we are going to create a new helper generator that simply adds some instance variable readers. First, we create a generator within the rails namespace, as this is where rails searches for generators used as hooks:

$ bin/rails --version

```

### Creating the Blog Application

In the above image, the bottom line has been truncated. Let's see what the full

thing looks like:

That's quite a lot of text! Let's quickly go through and understand what each

part of it does.

### The first form

method called `form_for`. To use this method, add this code into

`app/views/articles/new.html.erb`:

(images/getting_started/forbidden_attributes_for_new_article.png)

Rails has several security features that help you write secure applications,

which requires us to tell Rails exactly which parameters are allowed into our

controller actions.

NOTE: The backend will lazy-load these translations when a translation is looked up for the first time. This makes it possible to just swap the backend with something else even after translations have already been announced.

```ruby

# The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.

However, you would probably like to **provide support for more locales** in your application. In such case, you need to set and pass the locale between requests.

The _setting part_ is easy. You can set the locale in a `before_action` in the `ApplicationController` like this:

Do take special care about the **order of your routes**, so this route declaration does not "eat" other ones. (You may want to add it directly before the `root :to` declaration.)

### Setting the Locale from the Client Supplied Information

### Inflection Rules For Other Locales

### Localized Views

You can make use of this feature, e.g. when working with a large amount of static content, which would be clumsy to put inside YAML or Ruby dictionaries. Bear in mind, though, that any change you would like to do later to the template must be propagated to all of them.

The threats against web applications include user account hijacking, bypass of access control, reading or modifying sensitive data, or presenting fraudulent content. Or an attacker might be able to install a Trojan horse program or unsolicited e-mail sending software, aim at financial enrichment or cause brand name damage by modifying company resources. In order to prevent attacks, minimize their impact and remove points of attack, first of all, you have to fully understand the attack methods in order to find the correct countermeasures. That is what this guide aims at.

Sessions

--------

* Most people don't clear out the cookies after working at a public terminal. So if the last user didn't log out of a web application, you would be able to use it as this user. Provide the user with a _log-out button_ in the web application, and _make it prominent_.

* Instead of stealing a cookie unknown to the attacker, they fix a user's session identifier (in the cookie) known to them. Read more about this so-called session fixation later.


* Bob browses a message board and views a post from a hacker where there is a crafted HTML image element. The element references a command in Bob's project management application, rather than an image file.

* `<img src="http://www.webapp.com/project/1/destroy">`

The above method can be placed in the `ApplicationController` and will be called when a CSRF token is not present or is incorrect on a non-GET request.

Redirection and Files

---------------------

INFO: _Do you find it hard to remember all your passwords? Don't write them down, but use the initial letters of each word in an easy to remember sentence._

password1, abc123, myspace1, password, blink182, qwerty1, ****you, 123abc, baseball1, football1, 123456, soccer, monkey1, liverpool1, princess1, jordan23, slipknot1, superman1, iloveyou1, and monkey.

#### Countermeasures

Instead of passing a string to the conditions option, you can pass an array to sanitize tainted strings like this:

For this guide we will be using Rails _scaffolding_. It will create the model, a migration, controller and views for the new resource in a single operation. It will also create a full test suite following Rails best practices. We will be using examples from this generated code and will be supplementing it with additional examples where necessary.

When you use `rails generate scaffold`, for a resource among other things it creates a test stub in the `test/models` folder:

This guide provides steps to be followed when you upgrade your applications to a newer version of Ruby on Rails. These steps are also available in individual release guides.

General Advice

--------------

adding the [`activesupport-json_encoder`](https://github.com/rails/activesupport-json_encoder)

gem to your Gemfile.

### Usage of `return` within inline callback blocks

Previously, Rails allowed inline callback blocks to use `return` this way:

`store_accessors` based on top of `json` or `hstore` columns. Make sure to use

string keys consistently.

Upgrading from Rails 3.2 to Rails 4.0

-------------------------------------

*Rafael Mendonça França*

initializer :add_builtin_route do |app|

if Rails.env.development?

app.routes.append do

get '/rails/info/properties' => "rails/info#properties"

get '/rails/info/routes' => "rails/info#routes"

get '/rails/info' => "rails/info#index"

def rails_gemfile_entry

if options.dev?

[GemfileEntry.path('rails', Rails::Generators::RAILS_DEV_PATH),

elsif options.edge?

[GemfileEntry.github('rails', 'rails/rails'),

else

[GemfileEntry.version('rails',

Rails::VERSION::STRING,

<h1>Listing <%= plural_table_name.titleize %></h1>

<table>

ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)

assert db_config.is_a?(Hash)

end

end

end

assert_equal 404, last_response.status

end

test "mailer previews are loaded from the default preview_path" do

mailer 'notifier', <<-RUBY

class Notifier < ActionMailer::Base

assert_match %r{/app/test/unit/failing_test\.rb}, output

end

output = script('generate model user name:string')

version = output.match(/(\d+)_create_users\.rb/)[1]

assert !result.include?("create_table(:users)")

end

private

def assert_unsuccessful_run(name, message)

result = run_test_file(name)

def test_skip_routes

run_generator ["account", "foo", "--skip-routes"]

assert_file "config/routes.rb" do |routes|

end

end

assert_no_file "app/views/layouts/users.html.erb"

end

def test_functional_tests

run_generator ["User", "name:string", "age:integer", "organization:references{polymorphic}"]

def setup

@subscriber = Subscriber.new

@notifier = ActiveSupport::Notifications.notifier

end

def teardown

end

def test_notification