* Add DSL for configuring HTTP Feature Policy

This new DSL provides a way to configure a HTTP Feature Policy at a

#

# Show a 404 page in the browser:

#

#

# Read about the other Content-* HTTP headers if you'd like to

# provide the user with more information (such as Content-Description) in

@parameters == other

end

end

# Returns a safe <tt>ActiveSupport::HashWithIndifferentAccess</tt>

# representation of the parameters with all unpermitted keys removed.

object_src: "object-src",

prefetch_src: "prefetch-src",

script_src: "script-src",

style_src: "style-src",

worker_src: "worker-src"

}.freeze

return unless logger

exception = wrapper.exception

ActiveSupport::Deprecation.silence do

message = []

"ActionView::Template::Error"

]

attr_reader :backtrace_cleaner, :exception, :wrapped_causes, :line_number, :file

def initialize(backtrace_cleaner, exception)

@backtrace_cleaner = backtrace_cleaner

@exception = exception

@wrapped_causes = wrapped_causes_for(exception, backtrace_cleaner)

expand_backtrace if exception.is_a?(SyntaxError) || exception.cause.is_a?(SyntaxError)

end

def unwrapped_exception

exception.cause

else

exception

end

def rescue_template

end

def status_code

self.class.status_code_for_exception(unwrapped_exception.class.name)

end

def application_trace

clean_backtrace(:silent)

end

ActionDispatch.test_app = app

end

end

end

def initialize(*) # :nodoc:

super

self.class.driver.use

end

def self.start_application # :nodoc:

driven_by :selenium

end

ActiveSupport.run_load_hooks(:action_dispatch_system_test_case, self)

params1 = ActionController::Parameters.new(a: 1, b: 2)

params2 = ActionController::Parameters.new(a: 1, b: 2)

assert(params1 == params2)

end

test "is equal to Parameters instance with same permitted params" do

params1 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)

params2 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)

assert(params1 == params2)

end

test "is equal to Parameters instance with same different source params, but same permitted params" do

params2 = ActionController::Parameters.new(a: 1, c: 3).permit(:a)

assert(params1 == params2)

assert(params2 == params1)

end

test "is not equal to an unpermitted Parameters instance with same params" do

params2 = ActionController::Parameters.new(a: 1)

assert(params1 != params2)

assert(params2 != params1)

end

test "is not equal to Parameters instance with different permitted params" do

params2 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)

assert(params1 != params2)

assert(params2 != params1)

end

test "equality with simple types works" do

@policy.script_src false

assert_no_match %r{script-src}, @policy.build

@policy.style_src :self

assert_match %r{style-src 'self'}, @policy.build

@policy.style_src false

assert_no_match %r{style-src}, @policy.build

@policy.worker_src :self

assert_match %r{worker-src 'self'}, @policy.build

end

test "logs exception backtrace when all lines silenced" do

output = StringIO.new

backtrace_cleaner = ActiveSupport::BacktraceCleaner.new

backtrace_cleaner.add_silencer { true }

assert_operator((output.rewind && output.read).lines.count, :>, 10)

end

test "display backtrace when error type is SyntaxError" do

@app = DevelopmentApp

# which is implemented by sprockets-rails.

#

# asset_path("application.js") # => "/assets/application-60aa4fdc5cea14baf5400fba1abf4f2a46a5166bad4772b1effe341570f07de9.js"

#

# === Without the asset pipeline (<tt>skip_pipeline: true</tt>)

#

# Creates an anchor element of the given +name+ using a URL created by the set of +options+.

# See the valid options in the documentation for +url_for+. It's also possible to

# of an options hash will generate a link to the referrer (a JavaScript back link

# will be used in place of a referrer if none exists). If +nil+ is passed as the name

# the value of the link itself will become the name.

# The +options+ hash accepts the same options as +url_for+.

#

# There are a few special +html_options+:

# <tt>:delete</tt>, <tt>:patch</tt>, and <tt>:put</tt>. By default it will be <tt>:post</tt>.

# * <tt>:disabled</tt> - If set to true, it will generate a disabled button.

# * <tt>:data</tt> - This option can be used to add custom data attributes.

# * <tt>:form</tt> - This hash will be form attributes

# * <tt>:form_class</tt> - This controls the class of the form within which the submit button will

# be placed

#

# ==== Data attributes

#

end

end

private

def convert_options_to_data_attributes(options, html_options)

if html_options

module ActionView

class UnboundTemplate

@source = source

@handler = handler

@options = options

options = @options.merge(locals: locals)

Template.new(

@source,

@handler,

options

)

assert_equal({ class: "special" }, options)

end

def protect_against_forgery?

request_forgery

end

eager_autoload do

autoload :Errors

autoload :RangeError, "active_model/errors"

autoload :StrictValidationFailed, "active_model/errors"

autoload :UnknownAttributeError, "active_model/errors"

# frozen_string_literal: true

module ActiveModel

# == Active \Model \Error

#

CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]

MESSAGE_OPTIONS = [:message]

def initialize(base, attribute, type = :invalid, **options)

@base = base

@attribute = attribute

def message

case raw_type

when Symbol

else

raw_type

end

end

def full_message

end

# See if error matches provided +attribute+, +type+ and +options+.

end

def strict_match?(attribute, type, **options)

end

def ==(other)

protected

def attributes_for_hash

end

end

end

LEGACY_ATTRIBUTES = [:messages, :details].freeze

attr_reader :errors

alias :objects :errors

matches.each do |error|

@errors.delete(error)

end

end

# When passed a symbol or a name of a method, returns an array of errors

# # then yield :name and "must be specified"

# end

def each(&block)

@errors.each(&block)

else

ActiveSupport::Deprecation.warn(<<~MSG)

hash

end

def messages

DeprecationHandlingMessageHash.new(self)

end

#

# person.errors.full_message(:name, 'is invalid') # => "Name is invalid"

def full_message(attribute, message)

end

# Translates an error message in its default scope

# * <tt>errors.attributes.title.blank</tt>

# * <tt>errors.messages.blank</tt>

def generate_message(attribute, type = :invalid, options = {})

end

def marshal_load(array) # :nodoc:

end

initializer "active_model.i18n_customize_full_message" do

end

end

end

assert_includes errors, "foo", "errors should include 'foo' as :foo"

end

def test_any?

errors = ActiveModel::Errors.new(Person.new)

errors.add(:name)

assert_equal [msg], person.errors[:name]

end

test "added? detects indifferent if a specific error was added to the object" do

person = Person.new

person.errors.add(:name, "cannot be blank")

assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.to_a

end

test "to_hash returns the error messages hash" do

person = Person.new

person.errors.add(:name, "cannot be blank")

assert_nil person.errors.as_json.default_proc

end

test "full_messages creates a list of error messages with the attribute name included" do

person = Person.new

person.errors.add(:name, "cannot be blank")

assert_not_equal errors_dup.details, errors.details

end

test "delete removes details on given attribute" do

errors = ActiveModel::Errors.new(Person.new)

errors.add(:name, :invalid)

test "i18n customize full message defaults to false" do

@app.initialize!

end

test "i18n customize full message can be disabled" do

@app.config.active_model.i18n_customize_full_message = false

@app.initialize!

end

test "i18n customize full message can be enabled" do

@app.config.active_model.i18n_customize_full_message = true

@app.initialize!

end

end

I18n.backend = I18n::Backend::Simple.new

I18n.backend.store_translations("en", errors: { messages: { custom: nil } })

end

def teardown

I18n.load_path.replace @old_load_path

I18n.backend = @old_backend

I18n.backend.reload!

end

def test_full_message_encoding

end

def test_errors_full_messages_doesnt_use_attribute_format_without_config

I18n.backend.store_translations("en", activemodel: {

errors: { models: { person: { attributes: { name: { format: "%{message}" } } } } } })

assert_equal "Name test cannot be blank", person.errors.full_message(:name_test, "cannot be blank")

end

def test_errors_full_messages_uses_attribute_format

I18n.backend.store_translations("en", activemodel: {

errors: { models: { person: { attributes: { name: { format: "%{message}" } } } } } })

end

def test_errors_full_messages_uses_model_format

I18n.backend.store_translations("en", activemodel: {

errors: { models: { person: { format: "%{message}" } } } })

end

def test_errors_full_messages_uses_deeply_nested_model_attributes_format

I18n.backend.store_translations("en", activemodel: {

errors: { models: { 'person/contacts/addresses': { attributes: { street: { format: "%{message}" } } } } } })

end

def test_errors_full_messages_uses_deeply_nested_model_model_format

I18n.backend.store_translations("en", activemodel: {

errors: { models: { 'person/contacts/addresses': { format: "%{message}" } } } })

end

def test_errors_full_messages_with_indexed_deeply_nested_attributes_and_attributes_format

I18n.backend.store_translations("en", activemodel: {

errors: { models: { 'person/contacts/addresses': { attributes: { street: { format: "%{message}" } } } } } })

end

def test_errors_full_messages_with_indexed_deeply_nested_attributes_and_model_format

I18n.backend.store_translations("en", activemodel: {

errors: { models: { 'person/contacts/addresses': { format: "%{message}" } } } })

end

def test_errors_full_messages_with_indexed_deeply_nested_attributes_and_i18n_attribute_name

I18n.backend.store_translations("en", activemodel: {

attributes: { 'person/contacts/addresses': { country: "Country" } }

end

def test_errors_full_messages_with_indexed_deeply_nested_attributes_without_i18n_config

I18n.backend.store_translations("en", activemodel: {

errors: { models: { 'person/contacts/addresses': { attributes: { street: { format: "%{message}" } } } } } })

end

def test_errors_full_messages_with_i18n_attribute_name_without_i18n_config

I18n.backend.store_translations("en", activemodel: {

attributes: { 'person/contacts[0]/addresses[0]': { country: "Country" } }

test "validates_confirmation_of on generated message #{name}" do

person_class.validates_confirmation_of :title, validation_options

@person.title_confirmation = "foo"

@person.valid?

@person.errors.messages

end

COMMON_CASES.each do |name, validation_options, generate_message_options|

test "validates_acceptance_of on generated message #{name}" do

person_class.validates_acceptance_of :title, validation_options.merge(allow_nil: false)

@person.valid?

@person.errors.messages

end

COMMON_CASES.each do |name, validation_options, generate_message_options|

test "validates_presence_of on generated message #{name}" do

person_class.validates_presence_of :title, validation_options

@person.valid?

@person.errors.messages

end

COMMON_CASES.each do |name, validation_options, generate_message_options|

test "validates_length_of for :within on generated message when too short #{name}" do

person_class.validates_length_of :title, validation_options.merge(within: 3..5)

@person.valid?

@person.errors.messages

end

test "validates_length_of for :too_long generated message #{name}" do

person_class.validates_length_of :title, validation_options.merge(within: 3..5)

@person.title = "this title is too long"

@person.valid?

@person.errors.messages

end

COMMON_CASES.each do |name, validation_options, generate_message_options|

test "validates_length_of for :is on generated message #{name}" do

person_class.validates_length_of :title, validation_options.merge(is: 5)

@person.valid?

@person.errors.messages

end

test "validates_format_of on generated message #{name}" do

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

@person.title = "72x"

@person.valid?

@person.errors.messages

end

test "validates_inclusion_of on generated message #{name}" do

person_class.validates_inclusion_of :title, validation_options.merge(in: %w(a b c))

@person.title = "z"

@person.valid?

@person.errors.messages

end

test "validates_inclusion_of using :within on generated message #{name}" do

person_class.validates_inclusion_of :title, validation_options.merge(within: %w(a b c))

@person.title = "z"

@person.valid?

@person.errors.messages

end

test "validates_exclusion_of generated message #{name}" do

person_class.validates_exclusion_of :title, validation_options.merge(in: %w(a b c))

@person.title = "a"

@person.valid?

@person.errors.messages

end

test "validates_exclusion_of using :within generated message #{name}" do

person_class.validates_exclusion_of :title, validation_options.merge(within: %w(a b c))

@person.title = "a"

@person.valid?

@person.errors.messages

end

test "validates_numericality_of generated message #{name}" do

person_class.validates_numericality_of :title, validation_options

@person.title = "a"

@person.valid?

@person.errors.messages

end

test "validates_numericality_of for :only_integer on generated message #{name}" do

person_class.validates_numericality_of :title, validation_options.merge(only_integer: true)

@person.title = "0.0"

@person.valid?

@person.errors.messages

end

test "validates_numericality_of for :odd on generated message #{name}" do

person_class.validates_numericality_of :title, validation_options.merge(only_integer: true, odd: true)

@person.title = 0

@person.valid?

@person.errors.messages

end

test "validates_numericality_of for :less_than on generated message #{name}" do

person_class.validates_numericality_of :title, validation_options.merge(only_integer: true, less_than: 0)

@person.title = 1

@person.valid?

@person.errors.messages

end

* Add database_exists? method to connection adapters to check if a database exists.

*Guilherme Mansur*

require "active_support/core_ext/string/behavior"

require "active_support/core_ext/kernel/singleton_class"

require "active_support/core_ext/module/introspection"

require "active_support/core_ext/class/subclasses"

require "active_record/attribute_decorators"

require "active_record/define_callbacks"

when ER_QUERY_INTERRUPTED

QueryCanceled.new(message, sql: sql, binds: binds)

else

end

end

value = value.sub(/^\((.+)\)$/, '-\1') # (4)

case value

value.gsub!(/[^-\d.]/, "")

value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")

end

class IrreversibleOrderError < ActiveRecordError

end

# LockWaitTimeout will be raised when lock wait timeout exceeded.

class LockWaitTimeout < StatementInvalid

end

# StatementTimeout will be raised when statement timeout exceeded.

end

# QueryCanceled will be raised when canceling statement due to user request.

end

# UnknownAttributeReference is raised when an unknown and potentially unsafe

end

end

task redo: :load_config do

raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?

# desc 'Resets your database using your migrations for the current environment'

task reset: ["db:drop", "db:create", "db:migrate"]

task up: :load_config do

ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:up")

end

end

task down: :load_config do

ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:down")

db_namespace["_dump"].invoke

end

task reset: [ "db:drop", "db:setup" ]

# desc "Retrieves the charset for the current environment's database"

ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|

ActiveRecord::Base.establish_connection(db_config.config)

# Skipped when no database

rescue ActiveRecord::NoDatabaseError

ActiveRecord::Tasks::DatabaseTasks.create_current(db_config.env_name, db_config.spec_name)

def optimizer_hints!(*args) # :nodoc:

args.flatten!

self

end

def between(other)

if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1

self.in([])

if other.end.nil? || open_ended?(other.end)

not_in([])

elsif other.exclude_end?

def not_between(other)

if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1

not_in([])

if other.end.nil? || open_ended?(other.end)

self.in([])

elsif other.exclude_end?

end

end

private

def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)

super(@conn, "ex", definition, &block)

test "raises StatementTimeout when statement timeout exceeded" do

skip unless ActiveRecord::Base.connection.show_variable("max_execution_time")

s = Sample.create!(value: 1)

latch1 = Concurrent::CountDownLatch.new

latch2 = Concurrent::CountDownLatch.new

thread.join

end

end

end

test "raises QueryCanceled when canceling statement due to user request" do

s = Sample.create!(value: 1)

latch = Concurrent::CountDownLatch.new

thread.join

end

end

end

end

end

type = PostgresqlMoney.type_for_attribute("wealth")

assert_equal(12345678.12, type.cast(+"$12,345,678.12"))

assert_equal(12345678.12, type.cast(+"$12.345.678,12"))

assert_equal(-1.15, type.cast(+"-$1.15"))

assert_equal(-2.25, type.cast(+"($2.25)"))

end

def test_schema_dumping

)

end

if Gem::Version.new("2.6.0") <= Gem::Version.new(RUBY_VERSION)

it "can be constructed with a range implicitly ending at Infinity" do

attribute = Attribute.new nil, nil

)

end

if Gem::Version.new("2.6.0") <= Gem::Version.new(RUBY_VERSION)

it "can be constructed with a range implicitly ending at Infinity" do

attribute = Attribute.new nil, nil

assert_match %r{/\*\+ BADHINT \*/}, post_with_hint.to_sql

end

class EnsureRoundTripTypeCasting < ActiveRecord::Type::Value

def type

:string

test "validates_uniqueness_of on generated message #{name}" do

Topic.validates_uniqueness_of :title, validation_options

@topic.title = unique_topic.title

@topic.valid?

@topic.errors.messages

end

COMMON_CASES.each do |name, validation_options, generate_message_options|

test "validates_associated on generated message #{name}" do

Topic.validates_associated :replies, validation_options

replied_topic.save

replied_topic.errors.messages

end

has_many :prisoners, inverse_of: :ship, foreign_key: :ship_id

has_many :parts, class_name: "ShipPart", foreign_key: :ship_id

end

class Prisoner < ActiveRecord::Base

* Image analysis is skipped if ImageMagick returns an error.

`ActiveStorage::Analyzer::ImageAnalyzer#metadata` would previously raise a

resolve("ActiveStorage::Blob") { |blob, options| route_for(:rails_blob, blob, options) }

resolve("ActiveStorage::Attachment") { |attachment, options| route_for(:rails_blob, attachment.blob, options) }

mattr_accessor :logger

mattr_accessor :verifier

mattr_accessor :queues, default: {}

mattr_accessor :previewers, default: []

mattr_accessor :paths, default: {}

mattr_accessor :content_types_to_serve_as_binary, default: []

mattr_accessor :service_urls_expire_in, default: 5.minutes

mattr_accessor :routes_prefix, default: "/rails/active_storage"

module Transformers

extend ActiveSupport::Autoload

end

def #{name}=(attachables)

end

end

CODE

ActiveStorage.analyzers = app.config.active_storage.analyzers || []

ActiveStorage.paths = app.config.active_storage.paths || {}

ActiveStorage.routes_prefix = app.config.active_storage.routes_prefix || "/rails/active_storage"

ActiveStorage.variable_content_types = app.config.active_storage.variable_content_types || []

ActiveStorage.content_types_to_serve_as_binary = app.config.active_storage.content_types_to_serve_as_binary || []

ActiveStorage.service_urls_expire_in = app.config.active_storage.service_urls_expire_in || 5.minutes

ActiveStorage.content_types_allowed_inline = app.config.active_storage.content_types_allowed_inline || []

ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"

end

end

purpose: :blob_key }

)

generated_url = url_helpers.rails_disk_service_url(verified_key_with_expiration,

disposition: content_disposition,

content_type: content_type,

filename: filename

end

end

test "attaching existing blobs to a new record" do

User.new(name: "Jason").tap do |user|

user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")

User.remove_method :highlights

end

end

end

include ActiveStorage::Service::SharedServiceTests

test "URL generation" do

end

test "headers_for_direct_upload generation" do

# frozen_string_literal: true

require "active_support/core_ext/string/inflections"

require "active_support/per_thread_registry"

end

def fetch_entry(key, options = nil) # :nodoc:

end

end

# The delegated method must be public on the target, otherwise it will

# raise +DelegationError+. If you wish to instead return +nil+,

# use the <tt>:allow_nil</tt> option.

def delegate_missing_to(target, allow_nil: nil)

target = target.to_s

target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)

# It may look like an oversight, but we deliberately do not pass

# +include_private+, because they do not get delegated.

#{target}.respond_to?(name) || super

end

end

end

def const_missing(const_name)

from_mod = anonymous? ? guess_for_anonymous(const_name) : self

Dependencies.load_missing_constant(from_mod, const_name)

base.class_eval do

define_method(:load, Kernel.instance_method(:load))

private :load

end

end

end

def hook!

end

def unhook!

# # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.

# (Backtrace information…)

# ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]

def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")

Kernel.require "active_support/inflector/methods"

@message = message

end

# Returns the class of the new constant.

#

# PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)

ActiveSupport::Inflector.constantize(@new_const.to_s)

end

end

end

end

# subscriber, the line above should be called after your

# <tt>ActiveRecord::LogSubscriber</tt> definition.

#

# After configured, whenever a <tt>"sql.active_record"</tt> notification is published,

# it will properly dispatch the event

# (<tt>ActiveSupport::Notifications::Event</tt>) to the sql method.

# Generates a signed message for the provided value.

#

#

# verifier = ActiveSupport::MessageVerifier.new 's3Krit'

# verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"

elsif value.is_a?(Hash)

value = call(value, parents, original_params)

elsif value.is_a?(Array)

elsif blocks.any?

key = key.dup if key.duplicable?

value = value.dup if value.duplicable?

end

end

def test_local_cache_of_read

@cache.write("foo", "bar")

@cache.with_local_cache do

end

end

class Block

def hello?

true

assert_respond_to DecoratedTester.new(@david), :extra_missing

end

def test_delegate_with_case

event = Event.new(Tester.new)

assert_equal 1, event.foo

C = 1

end

A = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("Deprecatee::A", "Deprecatee::B::C")

end

class DeprecateeWithAccessor

assert_not_deprecated { assert_equal Deprecatee::B::C.class, Deprecatee::A.class }

end

def test_deprecated_constant_accessor

assert_not_deprecated { DeprecateeWithAccessor::B::C }

assert_deprecated("DeprecateeWithAccessor::A") { assert_equal DeprecateeWithAccessor::B::C, DeprecateeWithAccessor::A }

value.replace("world!") if original_params["barg"]["blah"] == "bar" && key == "hello"

}

parameter_filter = ActiveSupport::ParameterFilter.new(filter_words)

before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo", "hello" => "world" } } }

after_filter["barg"] = { :bargain => "niag", "blah" => "[FILTERED]", "bar" => { "bargain" => { "blah" => "[FILTERED]", "hello" => "world!" } } }

assert_equal after_filter, parameter_filter.filter(before_filter)

end

end

select divider `option`.

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

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

* Add `preload_link_tag` helper.

is saved instead of immediately.

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

* Add the ability to reflect on defined attachments using the existing

Active Record reflection mechanism.

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

`mini_magick` directly.

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

Active Model

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

1.method(:+).duplicable? # => false

```

WARNING: Any class can disallow duplication by removing `dup` and `clone` or raising exceptions from them. Thus only `rescue` can tell whether a given arbitrary object is duplicable. `duplicable?` depends on the hard-coded list above, but it is much faster than `rescue`. Use it only if you know the hard-coded list is enough in your use case.

NOTE: Defined in `active_support/core_ext/object/duplicable.rb`.

[*object]

```

NOTE: Defined in `active_support/core_ext/array/wrap.rb`.

### Duplicating

* `config.active_record.lock_optimistically` controls whether Active Record will use optimistic locking and is `true` by default.

* `config.active_record.record_timestamps` is a boolean value which controls whether or not timestamping of `create` and `update` operations on a model occur. The default value is `true`.

config.active_storage.routes_prefix = '/files'

```

### Results of `load_defaults`

- `config.active_job.return_false_on_aborted_enqueue`: `true`

- `config.active_storage.queues.analysis`: `:active_storage_analysis`

- `config.active_storage.queues.purge`: `:active_storage_purge`

- `config.active_record.collection_cache_versioning`: `true`

### Configuring a Database

`jobs`, `mailers`, `models`, and `views` directories that you should be familiar with

from an application. We'll look more into models in a future section, when we're writing the engine.

`stylesheets` directories which, again, you should be familiar with due to their

similarity to an application. One difference here, however, is that each

directory contains a sub-directory with the engine name. Because this engine is

config.autoloader = :classic

```

Upgrading from Rails 5.1 to Rails 5.2

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

if respond_to?(:active_storage)

active_storage.queues.analysis = :active_storage_analysis

active_storage.queues.purge = :active_storage_purge

end

if respond_to?(:active_record)

in_root do

str = "gem #{parts.join(", ")}"

str = indentation + str

end

end

log :gemfile, "group #{str}"

in_root do

with_indentation(&block)

end

end

log :github, "github #{str}"

in_root do

with_indentation(&block)

end

end

in_root do

if block

with_indentation(&block)

else

prepend_file "Gemfile", "source #{quote(source)}\n", verbose: false

end

ensure

@indentation -= 1

end

end

end

end

class_option :skip_namespace, type: :boolean, default: false,

desc: "Skip namespace (affects only isolated applications)"

add_runtime_options!

strict_args_position!

# application or Ruby on Rails.

def class_collisions(*class_names)

return unless behavior == :invoke

class_names.flatten.each do |class_name|

class_name = class_name.to_s

if last && last.const_defined?(last_name.camelize, false)

raise Error, "The name '#{class_name}' is either already used in your application " \

end

end

end

# Be sure to restart your server when you modify this file.

# Configure sensitive parameters which will be filtered from the log file.

# Rails.application.config.active_storage.queues.analysis = :active_storage_analysis

# Rails.application.config.active_storage.queues.purge = :active_storage_purge

# Use ActionMailer::MailDeliveryJob for sending parameterized and normal mail.

#

# The default delivery jobs (ActionMailer::Parameterized::DeliveryJob, ActionMailer::DeliveryJob),

#

environment ENV.fetch("RAILS_ENV") { "development" }

# Specifies the number of `workers` to boot in clustered mode.

# Workers are forked web server processes. If using threads and workers together

# the concurrency of the application would be max `threads` * `workers`.

require "active_support/deprecation"

module Rails

# Implements the logic behind <tt>Rails::Command::NotesCommand</tt>. See <tt>rails notes --help</tt> for usage information.

#

end

end

end

MESSAGE

end

test "hosts include .localhost in development" do

app "development"

assert_includes Rails.application.config.hosts, ".localhost"

assert_no_match "active_record:migration", output

end

end

end

end

assert_match(/CreateRecipes: migrated/, output)

end

end

end

end

end

def test_add_source_adds_source_to_gemfile

run_generator

action :add_source, "http://gems.github.com"

end

def test_add_source_with_block_adds_source_to_gemfile_with_gem

action :add_source, "http://gems.github.com" do

gem "rspec-rails"

end

end

def test_add_source_with_block_adds_source_to_gemfile_after_gem

action :add_source, "http://gems.github.com" do

gem "rspec-rails"

end

end

def test_gem_should_put_gem_dependency_in_gemfile

run_generator

action :gem, "will-paginate"

end

def test_gem_with_version_should_include_version_in_gemfile

gem "fakeweb"

end

end

def test_github_should_create_an_indented_block

gem "baz"

end

end

def test_github_should_create_an_indented_block_with_options

gem "baz"

end

end

def test_github_should_create_an_indented_block_within_a_group

gem "bar"

gem "baz"

end

end

end

def test_environment_should_include_data_in_environment_initializer_block