-
-
-
- <%= alert %>
+ # <% end %> + # + # Since +local_assigns+ returns a +Hash+ instance, you can conditionally + # read a variable, then fall back to a default value when + # the key isn't part of the locals: { ... } options: + # + # <% local_assigns.fetch(:alerts, []).each do |alert| %> + #<%= alert %>
+ # <% end %> + # + # Combining Ruby 3.1's pattern matching assignment with calls to + # +Hash#with_defaults+ enables compact partial-local variable + # assignments: + # + # <% local_assigns.with_defaults(alerts: []) => { headline:, alerts: } %> + # + #<%= alert %>
+ # <% end %> + # eager_autoload do autoload :Error diff --git a/actionview/lib/action_view/test_case.rb b/actionview/lib/action_view/test_case.rb index e454f0792dad6..0d9bfacd9fdb7 100644 --- a/actionview/lib/action_view/test_case.rb +++ b/actionview/lib/action_view/test_case.rb @@ -9,6 +9,9 @@ module ActionView # = Action View Test Case + # + # Read more about ActionView::TestCase in {Testing Rails Applications}[https://guides.rubyonrails.org/testing.html#testing-view-partials] + # in the guides. class TestCase < ActiveSupport::TestCase class TestController < ActionController::Base include ActionDispatch::TestProcess @@ -57,9 +60,96 @@ module Behavior include ActiveSupport::Testing::ConstantLookup delegate :lookup_context, to: :controller - attr_accessor :controller, :request, :output_buffer, :rendered + attr_accessor :controller, :request, :output_buffer module ClassMethods + def inherited(descendant) # :nodoc: + super + + descendant_content_class = content_class.dup + + if descendant_content_class.respond_to?(:set_temporary_name) + descendant_content_class.set_temporary_name("rendered_content") + end + + descendant.content_class = descendant_content_class + end + + # Register a callable to parse rendered content for a given template + # format. + # + # Each registered parser will also define a +#rendered.[FORMAT]+ helper + # method, where +[FORMAT]+ corresponds to the value of the + # +format+ argument. + # + # === Arguments + # + # format - Symbol the name of the format used to render view's content + # callable - Callable to parse the String. Accepts the String. + # value as its only argument. + # block - Block serves as the parser when the + # callable is omitted. + # + # By default, ActionView::TestCase defines a parser for: + # + # * :html - returns an instance of Nokogiri::XML::Node + # * :json - returns an instance of ActiveSupport::HashWithIndifferentAccess + # + # Each pre-registered parser also defines a corresponding helper: + # + # * :html - defines `rendered.html` + # * :json - defines `rendered.json` + # + # === Examples + # + # test "renders HTML" do + # article = Article.create!(title: "Hello, world") + # + # render partial: "articles/article", locals: { article: article } + # + # assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } } + # end + # + # test "renders JSON" do + # article = Article.create!(title: "Hello, world") + # + # render formats: :json, partial: "articles/article", locals: { article: article } + # + # assert_pattern { rendered.json => { title: "Hello, world" } } + # end + # + # To parse the rendered content into RSS, register a call to RSS::Parser.parse: + # + # register_parser :rss, -> rendered { RSS::Parser.parse(rendered) } + # + # test "renders RSS" do + # article = Article.create!(title: "Hello, world") + # + # render formats: :rss, partial: article + # + # assert_equal "Hello, world", rendered.rss.items.last.title + # end + # + # To parse the rendered content into a Capybara::Simple::Node, + # re-register an :html parser with a call to + # Capybara.string: + # + # register_parser :html, -> rendered { Capybara.string(rendered) } + # + # test "renders HTML" do + # article = Article.create!(title: "Hello, world") + # + # render partial: article + # + # rendered.html.assert_css "h1", text: "Hello, world" + # end + def register_parser(format, callable = nil, &block) + parser = callable || block || :itself.to_proc + content_class.redefine_method(format) do + parser.call(to_s) + end + end + def tests(helper_class) case helper_class when String, Symbol @@ -105,6 +195,27 @@ def include_helper_modules! end end + included do + class_attribute :content_class, instance_accessor: false, default: Content + + setup :setup_with_controller + + register_parser :html, -> rendered { Rails::Dom::Testing.html_document.parse(rendered).root } + register_parser :json, -> rendered { JSON.parse(rendered, object_class: ActiveSupport::HashWithIndifferentAccess) } + + ActiveSupport.run_load_hooks(:action_view_test_case, self) + + helper do + def protect_against_forgery? + false + end + + def _test_case + controller._test_case + end + end + end + def setup_with_controller controller_class = Class.new(ActionView::TestCase::TestController) @controller = controller_class.new @@ -131,10 +242,64 @@ def rendered_views @_rendered_views ||= RenderedViewsCollection.new end + # Returns the content rendered by the last +render+ call. + # + # The returned object behaves like a string but also exposes a number of methods + # that allows you to parse the content string in formats registered using + # .register_parser. + # + # By default includes the following parsers: + # + # +.html+ + # + # Parse the rendered content String into HTML. By default, this means + # a Nokogiri::XML::Node. + # + # test "renders HTML" do + # article = Article.create!(title: "Hello, world") + # + # render partial: "articles/article", locals: { article: article } + # + # assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } } + # end + # + # To parse the rendered content into a Capybara::Simple::Node, + # re-register an :html parser with a call to + # Capybara.string: + # + # register_parser :html, -> rendered { Capybara.string(rendered) } + # + # test "renders HTML" do + # article = Article.create!(title: "Hello, world") + # + # render partial: article + # + # rendered.html.assert_css "h1", text: "Hello, world" + # end + # + # +.json+ + # + # Parse the rendered content String into JSON. By default, this means + # a ActiveSupport::HashWithIndifferentAccess. + # + # test "renders JSON" do + # article = Article.create!(title: "Hello, world") + # + # render formats: :json, partial: "articles/article", locals: { article: article } + # + # assert_pattern { rendered.json => { title: "Hello, world" } } + # end + def rendered + @_rendered ||= self.class.content_class.new(@rendered) + end + def _routes @controller._routes if @controller.respond_to?(:_routes) end + class Content < SimpleDelegator + end + # Need to experiment if this priority is the best one: rendered => output_buffer class RenderedViewsCollection def initialize @@ -161,21 +326,6 @@ def view_rendered?(view, expected_locals) end end - included do - setup :setup_with_controller - ActiveSupport.run_load_hooks(:action_view_test_case, self) - - helper do - def protect_against_forgery? - false - end - - def _test_case - controller._test_case - end - end - end - private # Need to experiment if this priority is the best one: rendered => output_buffer def document_root_element diff --git a/actionview/package.json b/actionview/package.json index b5ee28775af56..c7d394fe0d24b 100644 --- a/actionview/package.json +++ b/actionview/package.json @@ -1,6 +1,6 @@ { "name": "@rails/ujs", - "version": "7.1.0-alpha", + "version": "7.2.0-alpha", "description": "Ruby on Rails unobtrusive scripting adapter", "main": "app/assets/javascripts/rails-ujs.js", "module": "app/assets/javascripts/rails-ujs.esm.js", diff --git a/actionview/test/actionpack/controller/render_test.rb b/actionview/test/actionpack/controller/render_test.rb index 160ec46d0fd4b..b61b7bcedb30d 100644 --- a/actionview/test/actionpack/controller/render_test.rb +++ b/actionview/test/actionpack/controller/render_test.rb @@ -1347,7 +1347,7 @@ def test_partial_with_form_builder_and_invalid_model_custom_rendering_field_erro get :partial_with_form_builder_and_invalid_model assert_equal <<~HTML.strip, @response.body.strip -\">limelight
", str end + def test_content_tag_with_invalid_html_tag + invalid_tags = ["12p", "", "image file", "div/", "my>element", "_header"] + invalid_tags.each do |tag_name| + assert_raise(ArgumentError, "expected #{tag_name.inspect} to be invalid") do + content_tag(tag_name) + end + end + end + + def test_tag_with_invalid_html_tag + invalid_tags = ["12p", "", "image file", "div/", "my>element", "_header"] + invalid_tags.each do |tag_name| + assert_raise(ArgumentError, "expected #{tag_name.inspect} to be invalid") do + tag(tag_name) + end + end + end + def test_tag_builder_with_unescaped_conditional_hash_classes str = tag.p "limelight", class: { "song": true, "play>": true }, escape: false assert_equal "\">limelight
", str diff --git a/actionview/test/template/test_case_test.rb b/actionview/test/template/test_case_test.rb index 3a0166d29e92b..247d6b623a8fb 100644 --- a/actionview/test/template/test_case_test.rb +++ b/actionview/test/template/test_case_test.rb @@ -2,6 +2,7 @@ require "abstract_unit" require "rails/engine" +require "capybara/minitest" module ActionView module ATestHelper @@ -352,6 +353,94 @@ def render_from_helper end end + class PlaceholderAssertionsTest < ActionView::TestCase + helper_method def render_from_helper + content_tag "a", "foo", href: "/bar" + end + + test "supports placeholders in assert_select calls" do + render(partial: "test/from_helper") + + assert_select "a[href=?]", "/bar", text: "foo" + end + end + + class CapybaraHTMLEncoderTest < ActionView::TestCase + include ::Capybara::Minitest::Assertions + + def page + Capybara.string(document_root_element) + end + + test "document_root_element can be configured to utilize Capybara" do + developer = DeveloperStruct.new("Eloy") + + render "developers/developer_with_h1", developer: developer + + assert_kind_of Capybara::Node::Simple, page + assert_css "h1", text: developer.name + end + end + + class RenderedMethodMissingTest < ActionView::TestCase + test "rendered delegates methods to the String" do + developer = DeveloperStruct.new("Eloy") + + render "developers/developer", developer: developer + + assert_kind_of String, rendered.to_s + assert_equal developer.name, rendered + assert_match rendered, /#{developer.name}/ + assert_includes rendered, developer.name + end + end + + class HTMLParserTest < ActionView::TestCase + test "rendered.html is a Nokogiri::XML::Element" do + developer = DeveloperStruct.new("Eloy") + + render "developers/developer", developer: developer + + assert_kind_of Nokogiri::XML::Element, rendered.html + assert_equal developer.name, document_root_element.text + end + + test "do not memoize the rendered.html in view tests" do + concat form_tag("/foo") + + assert_equal "/foo", document_root_element.at("form")["action"] + + concat content_tag(:b, "Strong", class: "foo") + + assert_equal "/foo", document_root_element.at("form")["action"] + assert_equal "foo", document_root_element.at("b")["class"] + end + end + + class JSONParserTest < ActionView::TestCase + test "rendered.json is an ActiveSupport::HashWithIndifferentAccess" do + developer = DeveloperStruct.new("Eloy") + + render formats: :json, partial: "developers/developer", locals: { developer: developer } + + assert_kind_of ActiveSupport::HashWithIndifferentAccess, rendered.json + assert_equal developer.name, rendered.json[:name] + end + end + + class MissingHTMLParserTest < ActionView::TestCase + register_parser :html, nil + + test "rendered.html falls back to returning the value when the parser is missing" do + developer = DeveloperStruct.new("Eloy") + + render "developers/developer", developer: developer + + assert_kind_of String, rendered.html + assert_equal developer.name, rendered.html + end + end + module AHelperWithInitialize def initialize(*) super @@ -365,3 +454,7 @@ class AHelperWithInitializeTest < ActionView::TestCase end end end + +if RUBY_VERSION >= "3.1" + require_relative "./test_case_test/pattern_matching_test_cases" +end diff --git a/actionview/test/template/test_case_test/pattern_matching_test_cases.rb b/actionview/test/template/test_case_test/pattern_matching_test_cases.rb new file mode 100644 index 0000000000000..f2df2124fe8f8 --- /dev/null +++ b/actionview/test/template/test_case_test/pattern_matching_test_cases.rb @@ -0,0 +1,35 @@ +# frozen_string_literal: true + +class ActionView::PatternMatchingTestCases < ActionView::TestCase + test "document_root_element integrates with pattern matching" do + developer = DeveloperStruct.new("Eloy") + + render "developers/developer_with_h1", developer: developer + + # rubocop:disable Lint/Syntax + assert_pattern { document_root_element.at("h1") => { content: "Eloy", attributes: [{ name: "id", value: "name" }] } } + refute_pattern { document_root_element.at("h1") => { content: "Not Eloy" } } + end + + test "rendered.html integrates with pattern matching" do + developer = DeveloperStruct.new("Eloy") + + render "developers/developer", developer: developer + + # rubocop:disable Lint/Syntax + assert_pattern { rendered.html => { content: "Eloy" } } + refute_pattern { rendered.html => { content: "Not Eloy" } } + # rubocop:enable Lint/Syntax + end + + test "rendered.json integrates with pattern matching" do + developer = DeveloperStruct.new("Eloy") + + render formats: :json, partial: "developers/developer", locals: { developer: developer } + + # rubocop:disable Lint/Syntax + assert_pattern { rendered.json => { name: "Eloy" } } + refute_pattern { rendered.json => { name: "Not Eloy" } } + # rubocop:enable Lint/Syntax + end +end diff --git a/actionview/test/template/text_helper_test.rb b/actionview/test/template/text_helper_test.rb index 775496f5d0097..279db5c99badb 100644 --- a/actionview/test/template/text_helper_test.rb +++ b/actionview/test/template/text_helper_test.rb @@ -68,6 +68,7 @@ def test_simple_format_should_not_sanitize_input_when_sanitize_option_is_false def test_simple_format_with_custom_wrapper assert_equal "", simple_format(nil, {}, { wrapper_tag: "div" }) + assert_equal "", simple_format(nil, {}, { wrapper_tag: nil }) end def test_simple_format_with_custom_wrapper_and_multi_line_breaks diff --git a/actionview/test/template/translation_helper_test.rb b/actionview/test/template/translation_helper_test.rb index da8807a20215c..ccf018dcd258b 100644 --- a/actionview/test/template/translation_helper_test.rb +++ b/actionview/test/template/translation_helper_test.rb @@ -117,25 +117,6 @@ def test_returns_missing_translation_message_does_filters_out_i18n_options assert_equal expected, translate(:"translations.missing", year: "2015", scope: %i(scoped)) end - def test_raises_missing_translation_message_with_raise_config_option - ActionView::Helpers::TranslationHelper.raise_on_missing_translations = true - - assert_raise(I18n::MissingTranslationData) do - translate("translations.missing") - end - ensure - ActionView::Helpers::TranslationHelper.raise_on_missing_translations = false - end - - def test_raise_arg_overrides_raise_config_option - ActionView::Helpers::TranslationHelper.raise_on_missing_translations = true - - expected = /translation missing: en.translations.missing/i - assert_match expected, translate(:"translations.missing", raise: false) - ensure - ActionView::Helpers::TranslationHelper.raise_on_missing_translations = false - end - def test_raises_missing_translation_message_with_raise_option assert_raise(I18n::MissingTranslationData) do translate(:"translations.missing", raise: true) diff --git a/activejob/CHANGELOG.md b/activejob/CHANGELOG.md index 7568300c83554..ba6d525b2074d 100644 --- a/activejob/CHANGELOG.md +++ b/activejob/CHANGELOG.md @@ -1,201 +1,2 @@ -* Add `after_discard` method. - This method lets job authors define a block which will be run when a job is about to be discarded. For example: - - ```ruby - class AfterDiscardJob < ActiveJob::Base - after_discard do |job, exception| - Rails.logger.info("#{job.class} raised an exception: #{exception}") - end - - def perform - raise StandardError - end - end - ``` - - The above job will run the block passed to `after_discard` after the job is discarded. The exception will - still be raised after the block has been run. - - *Rob Cardy* - -* Fix deserialization of ActiveSupport::Duration - - Previously, a deserialized Duration would return an array from Duration#parts. - It will now return a hash just like a regular Duration. - - This also fixes an error when trying to add or subtract from a deserialized Duration - (eg `duration + 1.year`). - - *Jonathan del Strother* - -* `perform_enqueued_jobs` is now compatible with all Active Job adapters - - This means that methods that depend on it, like Action Mailer's `assert_emails`, - will work correctly even if the test adapter is not used. - - *Alex Ghiculescu* - -* Allow queue adapters to provide a custom name by implementing `queue_adapter_name` - - *Sander Verdonschot* - -* Log background job enqueue callers - - Add `verbose_enqueue_logs` configuration option to display the caller - of background job enqueue in the log to help with debugging. - - Example log line: - - ``` - Enqueued AvatarThumbnailsJob (Job ID: ab528951-41fb-4c48-9129-3171791c27d6) to Sidekiq(default) with arguments: 1092412064 - ↳ app/models/user.rb:421:in `generate_avatar_thumbnails' - ``` - - Enabled in development only for new and upgraded applications. Not recommended for use - in the production environment since it relies on Ruby's `Kernel#caller` which is fairly slow. - - *fatkodima* - -* Set `provider_job_id` for Backburner jobs - - *Cameron Matheson* - -* Add `perform_all_later` to enqueue multiple jobs at once - - This adds the ability to bulk enqueue jobs, without running callbacks, by - passing multiple jobs or an array of jobs. For example: - - ```ruby - ActiveJob.perform_all_later(MyJob.new("hello", 42), MyJob.new("world", 0)) - - user_jobs = User.pluck(:id).map { |id| UserJob.new(user_id: id) } - ActiveJob.perform_all_later(user_jobs) - ``` - - This can greatly reduce the number of round-trips to the queue datastore. - For queue adapters that do not implement the new `enqueue_all` method, we - fall back to enqueuing jobs individually. The Sidekiq adapter implements - `enqueue_all` with `push_bulk`. - - This method does not use the existing `enqueue.active_job` event, but adds a - new event `enqueue_all.active_job`. - - *Sander Verdonschot* - -* Don't double log the `job` when using `ActiveRecord::QueryLog` - - Previously if you set `config.active_record.query_log_tags` to an array that included - `:job`, the job name would get logged twice. This bug has been fixed. - - *Alex Ghiculescu* - -* Add support for Sidekiq's transaction-aware client - - *Jonathan del Strother* - -* Remove QueAdapter from Active Job. - - After maintaining Active Job QueAdapter by Rails and Que side - to support Ruby 3 keyword arguments and options provided as top level keywords, - it is quite difficult to maintain it this way. - - Active Job Que adapter can be included in the future version of que gem itself. - - *Yasuo Honda* - -* Fix BigDecimal (de)serialization for adapters using JSON. - - Previously, BigDecimal was listed as not needing a serializer. However, - when used with an adapter storing the job arguments as JSON, it would get - serialized as a simple String, resulting in deserialization also producing - a String (instead of a BigDecimal). - - By using a serializer, we ensure the round trip is safe. - - To ensure applications using BigDecimal job arguments are not subject to - race conditions during deployment (where a replica running a version of - Rails without BigDecimalSerializer fails to deserialize an argument - serialized with it), `ActiveJob.use_big_decimal_serializer` is disabled by - default, and can be set to true in a following deployment.. - - *Sam Bostock* - -* Preserve full-precision `enqueued_at` timestamps for serialized jobs, - allowing more accurate reporting of how long a job spent waiting in the - queue before it was performed. - - Retains IS08601 format compatibility. - - *Jeremy Daer* - -* Add `--parent` option to job generator to specify parent class of job. - - Example: - - `bin/rails g job process_payment --parent=payment_job` generates: - - ```ruby - class ProcessPaymentJob < PaymentJob - # ... - end - ``` - - *Gannon McGibbon* - -* Add more detailed description to job generator. - - *Gannon McGibbon* - -* `perform.active_job` notification payloads now include `:db_runtime`, which - is the total time (in ms) taken by database queries while performing a job. - This value can be used to better understand how a job's time is spent. - - *Jonathan Hefner* - -* Update `ActiveJob::QueueAdapters::QueAdapter` to remove deprecation warning. - - Remove a deprecation warning introduced in que 1.2 to prepare for changes in - que 2.0 necessary for Ruby 3 compatibility. - - *Damir Zekic* and *Adis Hasovic* - -* Add missing `bigdecimal` require in `ActiveJob::Arguments` - - Could cause `uninitialized constant ActiveJob::Arguments::BigDecimal (NameError)` - when loading Active Job in isolation. - - *Jean Boussier* - -* Allow testing `discard_on/retry_on ActiveJob::DeserializationError` - - Previously in `perform_enqueued_jobs`, `deserialize_arguments_if_needed` - was called before calling `perform_now`. When a record no longer exists - and is serialized using GlobalID this led to raising - an `ActiveJob::DeserializationError` before reaching `perform_now` call. - This behavior makes difficult testing the job `discard_on/retry_on` logic. - - Now `deserialize_arguments_if_needed` call is postponed to when `perform_now` - is called. - - Example: - - ```ruby - class UpdateUserJob < ActiveJob::Base - discard_on ActiveJob::DeserializationError - - def perform(user) - # ... - end - end - - # In the test - User.destroy_all - assert_nothing_raised do - perform_enqueued_jobs only: UpdateUserJob - end - ``` - - *Jacopo Beschi* - -Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activejob/CHANGELOG.md) for previous changes. +Please check [7-1-stable](https://github.com/rails/rails/blob/7-1-stable/activejob/CHANGELOG.md) for previous changes. diff --git a/activejob/lib/active_job/core.rb b/activejob/lib/active_job/core.rb index 1743327486391..8304d6dd2379f 100644 --- a/activejob/lib/active_job/core.rb +++ b/activejob/lib/active_job/core.rb @@ -12,8 +12,10 @@ module Core attr_accessor :arguments attr_writer :serialized_arguments - # Timestamp when the job should be performed - attr_accessor :scheduled_at + # Time when the job should be performed + attr_reader :scheduled_at + + attr_reader :_scheduled_at_time # :nodoc: # Job Identifier attr_accessor :job_id @@ -94,6 +96,8 @@ def initialize(*arguments) @arguments = arguments @job_id = SecureRandom.uuid @queue_name = self.class.queue_name + @scheduled_at = nil + @_scheduled_at_time = nil @priority = self.class.priority @executions = 0 @exception_executions = {} @@ -115,7 +119,8 @@ def serialize "exception_executions" => exception_executions, "locale" => I18n.locale.to_s, "timezone" => timezone, - "enqueued_at" => Time.now.utc.iso8601(9) + "enqueued_at" => Time.now.utc.iso8601(9), + "scheduled_at" => _scheduled_at_time ? _scheduled_at_time.utc.iso8601(9) : nil, } end @@ -155,19 +160,32 @@ def deserialize(job_data) self.exception_executions = job_data["exception_executions"] self.locale = job_data["locale"] || I18n.locale.to_s self.timezone = job_data["timezone"] || Time.zone&.name - self.enqueued_at = job_data["enqueued_at"] + self.enqueued_at = Time.iso8601(job_data["enqueued_at"]) if job_data["enqueued_at"] + self.scheduled_at = Time.iso8601(job_data["scheduled_at"]) if job_data["scheduled_at"] end # Configures the job with the given options. def set(options = {}) # :nodoc: - self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait] - self.scheduled_at = options[:wait_until].to_f if options[:wait_until] + self.scheduled_at = options[:wait].seconds.from_now if options[:wait] + self.scheduled_at = options[:wait_until] if options[:wait_until] self.queue_name = self.class.queue_name_from_part(options[:queue]) if options[:queue] self.priority = options[:priority].to_i if options[:priority] self end + def scheduled_at=(value) + @_scheduled_at_time = if value.is_a?(Numeric) + ActiveJob.deprecator.warn(<<~MSG.squish) + Assigning a numeric/epoch value to scheduled_at is deprecated. Use a Time object instead. + MSG + Time.at(value) + else + value + end + @scheduled_at = value + end + private def serialize_arguments_if_needed(arguments) if arguments_serialized? diff --git a/activejob/lib/active_job/enqueuing.rb b/activejob/lib/active_job/enqueuing.rb index 357dcd71d0e7b..a805a53f62c3d 100644 --- a/activejob/lib/active_job/enqueuing.rb +++ b/activejob/lib/active_job/enqueuing.rb @@ -23,7 +23,7 @@ def perform_all_later(*jobs) adapter_jobs.each do |job| job.successfully_enqueued = false if job.scheduled_at - queue_adapter.enqueue_at(job, job.scheduled_at) + queue_adapter.enqueue_at(job, job._scheduled_at_time.to_f) else queue_adapter.enqueue(job) end @@ -92,7 +92,7 @@ def enqueue(options = {}) run_callbacks :enqueue do if scheduled_at - queue_adapter.enqueue_at self, scheduled_at + queue_adapter.enqueue_at self, _scheduled_at_time.to_f else queue_adapter.enqueue self end diff --git a/activejob/lib/active_job/exceptions.rb b/activejob/lib/active_job/exceptions.rb index 66111d919df3c..1ec5f0acb2c49 100644 --- a/activejob/lib/active_job/exceptions.rb +++ b/activejob/lib/active_job/exceptions.rb @@ -24,7 +24,7 @@ module ClassMethods # ==== Options # * :wait - Re-enqueues the job with a delay specified either in seconds (default: 3 seconds), # as a computing proc that takes the number of executions so far as an argument, or as a symbol reference of - # :exponentially_longer, which applies the wait algorithm of ((executions**4) + (Kernel.rand * (executions**4) * jitter)) + 2 + # :polynomially_longer, which applies the wait algorithm of ((executions**4) + (Kernel.rand * (executions**4) * jitter)) + 2 # (first wait ~3s, then ~18s, then ~83s, etc) # * :attempts - Re-enqueues the job the specified number of times (default: 5 attempts) or a symbol reference of :unlimited # to retry the job until it succeeds @@ -40,11 +40,11 @@ module ClassMethods # retry_on CustomInfrastructureException, wait: 5.minutes, attempts: :unlimited # # retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3 - # retry_on Net::OpenTimeout, Timeout::Error, wait: :exponentially_longer, attempts: 10 # retries at most 10 times for Net::OpenTimeout and Timeout::Error combined + # retry_on Net::OpenTimeout, Timeout::Error, wait: :polynomially_longer, attempts: 10 # retries at most 10 times for Net::OpenTimeout and Timeout::Error combined # # To retry at most 10 times for each individual exception: - # # retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 10 + # # retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10 # # retry_on Net::ReadTimeout, wait: 5.seconds, jitter: 0.30, attempts: 10 - # # retry_on Timeout::Error, wait: :exponentially_longer, attempts: 10 + # # retry_on Timeout::Error, wait: :polynomially_longer, attempts: 10 # # retry_on(YetAnotherCustomAppException) do |job, error| # ExceptionNotifier.caught(error) @@ -57,6 +57,12 @@ module ClassMethods # end # end def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: JITTER_DEFAULT) + if wait == :exponentially_longer + ActiveJob.deprecator.warn(<<~MSG.squish) + `wait: :exponentially_longer` will actually wait polynomially longer and is therefore deprecated. + Prefer `wait: :polynomially_longer` to avoid confusion and keep the same behavior. + MSG + end rescue_from(*exceptions) do |error| executions = executions_for(exceptions) if attempts == :unlimited || executions < attempts @@ -156,7 +162,8 @@ def determine_delay(seconds_or_duration_or_algorithm:, executions:, jitter: JITT jitter = jitter == JITTER_DEFAULT ? self.class.retry_jitter : (jitter || 0.0) case seconds_or_duration_or_algorithm - when :exponentially_longer + when :exponentially_longer, :polynomially_longer + # This delay uses a polynomial backoff strategy, which was previously misnamed as exponential delay = executions**4 delay_jitter = determine_jitter_for_delay(delay, jitter) delay + delay_jitter + 2 diff --git a/activejob/lib/active_job/gem_version.rb b/activejob/lib/active_job/gem_version.rb index d232f6796a1b4..ef81c3ee0b2bc 100644 --- a/activejob/lib/active_job/gem_version.rb +++ b/activejob/lib/active_job/gem_version.rb @@ -8,7 +8,7 @@ def self.gem_version module VERSION MAJOR = 7 - MINOR = 1 + MINOR = 2 TINY = 0 PRE = "alpha" diff --git a/activejob/lib/active_job/log_subscriber.rb b/activejob/lib/active_job/log_subscriber.rb index 98751bae73d43..5982fe3ef2441 100644 --- a/activejob/lib/active_job/log_subscriber.rb +++ b/activejob/lib/active_job/log_subscriber.rb @@ -8,7 +8,7 @@ class LogSubscriber < ActiveSupport::LogSubscriber # :nodoc: def enqueue(event) job = event.payload[:job] - ex = event.payload[:exception_object] + ex = event.payload[:exception_object] || job.enqueue_error if ex error do @@ -28,7 +28,7 @@ def enqueue(event) def enqueue_at(event) job = event.payload[:job] - ex = event.payload[:exception_object] + ex = event.payload[:exception_object] || job.enqueue_error if ex error do @@ -76,7 +76,7 @@ def enqueue_all(event) def perform_start(event) info do job = event.payload[:job] - "Performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} enqueued at #{job.enqueued_at}" + args_info(job) + "Performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} enqueued at #{job.enqueued_at.utc.iso8601(9)}" + args_info(job) end end subscribe_log_level :perform_start, :info diff --git a/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb b/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb index 9cf90b38f849a..55b578ae7cd63 100644 --- a/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb +++ b/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb @@ -54,7 +54,7 @@ def enqueue_all(jobs) # :nodoc: "wrapped" => job_class, "queue" => queue, "args" => scheduled_jobs.map { |job| [job.serialize] }, - "at" => scheduled_jobs.map { |job| job.scheduled_at } + "at" => scheduled_jobs.map { |job| job.scheduled_at&.to_f } ) enqueued_count += jids.compact.size end diff --git a/activejob/lib/active_job/queue_adapters/test_adapter.rb b/activejob/lib/active_job/queue_adapters/test_adapter.rb index 975ba9a7dfbb5..6e1c8ec6a2bbc 100644 --- a/activejob/lib/active_job/queue_adapters/test_adapter.rb +++ b/activejob/lib/active_job/queue_adapters/test_adapter.rb @@ -59,7 +59,7 @@ def filtered?(job) end def filtered_time?(job) - job.scheduled_at > at.to_f if at && job.scheduled_at + job.scheduled_at > at if at && job.scheduled_at end def filtered_queue?(job) diff --git a/activejob/lib/active_job/test_helper.rb b/activejob/lib/active_job/test_helper.rb index aee3fb7a9c160..6a96c2888241a 100644 --- a/activejob/lib/active_job/test_helper.rb +++ b/activejob/lib/active_job/test_helper.rb @@ -730,7 +730,7 @@ def deserialize_args_for_assertion(job) def instantiate_job(payload, skip_deserialize_arguments: false) job = payload[:job].deserialize(payload) - job.scheduled_at = payload[:at].to_f if payload.key?(:at) + job.scheduled_at = Time.at(payload[:at]) if payload.key?(:at) job.send(:deserialize_arguments_if_needed) unless skip_deserialize_arguments job end diff --git a/activejob/test/cases/exceptions_test.rb b/activejob/test/cases/exceptions_test.rb index 1f94dd6ef4868..08011e8b05fe9 100644 --- a/activejob/test/cases/exceptions_test.rb +++ b/activejob/test/cases/exceptions_test.rb @@ -108,23 +108,23 @@ class ExceptionsTest < ActiveSupport::TestCase end end - test "exponentially retrying job includes jitter" do + test "polynomially retrying job includes jitter" do travel_to Time.now random_amount = 2 delay_for_jitter = -> (delay) { random_amount * delay * ActiveJob::Base.retry_jitter } Kernel.stub(:rand, random_amount) do - RetryJob.perform_later "ExponentialWaitTenAttemptsError", 5, :log_scheduled_at + RetryJob.perform_later "PolynomialWaitTenAttemptsError", 5, :log_scheduled_at assert_equal [ - "Raised ExponentialWaitTenAttemptsError for the 1st time", + "Raised PolynomialWaitTenAttemptsError for the 1st time", "Next execution scheduled at #{(Time.now + 3.seconds + delay_for_jitter.(1)).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 2nd time", + "Raised PolynomialWaitTenAttemptsError for the 2nd time", "Next execution scheduled at #{(Time.now + 18.seconds + delay_for_jitter.(16)).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 3rd time", + "Raised PolynomialWaitTenAttemptsError for the 3rd time", "Next execution scheduled at #{(Time.now + 83.seconds + delay_for_jitter.(81)).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 4th time", + "Raised PolynomialWaitTenAttemptsError for the 4th time", "Next execution scheduled at #{(Time.now + 258.seconds + delay_for_jitter.(256)).to_f}", "Successfully completed job" ], JobBuffer.values @@ -140,16 +140,16 @@ class ExceptionsTest < ActiveSupport::TestCase random_amount = 1 Kernel.stub(:rand, random_amount) do - RetryJob.perform_later "ExponentialWaitTenAttemptsError", 5, :log_scheduled_at + RetryJob.perform_later "PolynomialWaitTenAttemptsError", 5, :log_scheduled_at assert_equal [ - "Raised ExponentialWaitTenAttemptsError for the 1st time", + "Raised PolynomialWaitTenAttemptsError for the 1st time", "Next execution scheduled at #{(Time.now + 7.seconds).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 2nd time", + "Raised PolynomialWaitTenAttemptsError for the 2nd time", "Next execution scheduled at #{(Time.now + 82.seconds).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 3rd time", + "Raised PolynomialWaitTenAttemptsError for the 3rd time", "Next execution scheduled at #{(Time.now + 407.seconds).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 4th time", + "Raised PolynomialWaitTenAttemptsError for the 4th time", "Next execution scheduled at #{(Time.now + 1282.seconds).to_f}", "Successfully completed job" ], JobBuffer.values @@ -175,16 +175,16 @@ class ExceptionsTest < ActiveSupport::TestCase ActiveJob::Base.retry_jitter = old_jitter end - test "random wait time for exponentially retrying job when retry jitter delay multiplier value is between 1 and 2" do + test "random wait time for polynomially retrying job when retry jitter delay multiplier value is between 1 and 2" do old_jitter = ActiveJob::Base.retry_jitter ActiveJob::Base.retry_jitter = 1.2 travel_to Time.now - RetryJob.perform_later "ExponentialWaitTenAttemptsError", 2, :log_scheduled_at + RetryJob.perform_later "PolynomialWaitTenAttemptsError", 2, :log_scheduled_at assert_not_equal [ - "Raised ExponentialWaitTenAttemptsError for the 1st time", + "Raised PolynomialWaitTenAttemptsError for the 1st time", "Next execution scheduled at #{(Time.now + 3.seconds).to_f}", "Successfully completed job" ], JobBuffer.values @@ -198,10 +198,10 @@ class ExceptionsTest < ActiveSupport::TestCase travel_to Time.now - RetryJob.perform_later "ExponentialWaitTenAttemptsError", 2, :log_scheduled_at + RetryJob.perform_later "PolynomialWaitTenAttemptsError", 2, :log_scheduled_at assert_not_equal [ - "Raised ExponentialWaitTenAttemptsError for the 1st time", + "Raised PolynomialWaitTenAttemptsError for the 1st time", "Next execution scheduled at #{(Time.now + 3.seconds).to_f}", "Successfully completed job" ], JobBuffer.values @@ -258,7 +258,7 @@ class ExceptionsTest < ActiveSupport::TestCase test "use individual execution timers when calculating retry delay" do travel_to Time.now - exceptions_to_raise = %w(ExponentialWaitTenAttemptsError CustomWaitTenAttemptsError ExponentialWaitTenAttemptsError CustomWaitTenAttemptsError) + exceptions_to_raise = %w(PolynomialWaitTenAttemptsError CustomWaitTenAttemptsError PolynomialWaitTenAttemptsError CustomWaitTenAttemptsError) random_amount = 1 @@ -268,11 +268,11 @@ class ExceptionsTest < ActiveSupport::TestCase delay_for_jitter = -> (delay) { random_amount * delay * ActiveJob::Base.retry_jitter } assert_equal [ - "Raised ExponentialWaitTenAttemptsError for the 1st time", + "Raised PolynomialWaitTenAttemptsError for the 1st time", "Next execution scheduled at #{(Time.now + 3.seconds + delay_for_jitter.(1)).to_f}", "Raised CustomWaitTenAttemptsError for the 2nd time", "Next execution scheduled at #{(Time.now + 2.seconds).to_f}", - "Raised ExponentialWaitTenAttemptsError for the 3rd time", + "Raised PolynomialWaitTenAttemptsError for the 3rd time", "Next execution scheduled at #{(Time.now + 18.seconds + delay_for_jitter.(16)).to_f}", "Raised CustomWaitTenAttemptsError for the 4th time", "Next execution scheduled at #{(Time.now + 4.seconds).to_f}", @@ -370,6 +370,30 @@ class ExceptionsTest < ActiveSupport::TestCase assert_equal expected_array, JobBuffer.values.last(2) end + class ::LegacyExponentialNamingError < StandardError; end + test "wait: :exponentially_longer is deprecated but still works" do + assert_deprecated(ActiveJob.deprecator) do + class LegacyRetryJob < RetryJob + retry_on LegacyExponentialNamingError, wait: :exponentially_longer, attempts: 10, jitter: nil + end + end + + travel_to Time.now + LegacyRetryJob.perform_later "LegacyExponentialNamingError", 5, :log_scheduled_at + + assert_equal [ + "Raised LegacyExponentialNamingError for the 1st time", + "Next execution scheduled at #{(Time.now + 3.seconds).to_f}", + "Raised LegacyExponentialNamingError for the 2nd time", + "Next execution scheduled at #{(Time.now + 18.seconds).to_f}", + "Raised LegacyExponentialNamingError for the 3rd time", + "Next execution scheduled at #{(Time.now + 83.seconds).to_f}", + "Raised LegacyExponentialNamingError for the 4th time", + "Next execution scheduled at #{(Time.now + 258.seconds).to_f}", + "Successfully completed job" + ], JobBuffer.values + end + private def adapter_skips_scheduling?(queue_adapter) [ diff --git a/activejob/test/cases/instrumentation_test.rb b/activejob/test/cases/instrumentation_test.rb new file mode 100644 index 0000000000000..50102061c1239 --- /dev/null +++ b/activejob/test/cases/instrumentation_test.rb @@ -0,0 +1,52 @@ +# frozen_string_literal: true + +require "helper" +require "jobs/hello_job" +require "jobs/retry_job" + +class InstrumentationTest < ActiveSupport::TestCase + include ActiveJob::TestHelper + + setup do + JobBuffer.clear + end + + test "perform_now emits perform events" do + events = subscribed(/perform.*\.active_job/) { HelloJob.perform_now("World!") } + assert_equal 2, events.size + assert_equal "perform_start.active_job", events[0].first + assert_equal "perform.active_job", events[1].first + end + + test "perform_later emits an enqueue event" do + events = subscribed("enqueue.active_job") { HelloJob.perform_later("World!") } + assert_equal 1, events.size + end + + test "retry emits an enqueue retry event" do + events = subscribed("enqueue_retry.active_job") do + perform_enqueued_jobs { RetryJob.perform_later("DefaultsError", 2) } + end + assert_equal 1, events.size + end + + test "retry exhaustion emits a retry_stopped event" do + events = subscribed("retry_stopped.active_job") do + perform_enqueued_jobs { RetryJob.perform_later("CustomCatchError", 6) } + end + assert_equal 1, events.size + end + + test "discard emits a discard event" do + events = subscribed("discard.active_job") do + perform_enqueued_jobs { RetryJob.perform_later("DiscardableError", 2) } + end + assert_equal 1, events.size + end + + def subscribed(name, &block) + [].tap do |events| + ActiveSupport::Notifications.subscribed(-> (*args) { events << args }, name, &block) + end + end +end diff --git a/activejob/test/cases/job_serialization_test.rb b/activejob/test/cases/job_serialization_test.rb index 4cf90412ac25b..f2b98958cdb5d 100644 --- a/activejob/test/cases/job_serialization_test.rb +++ b/activejob/test/cases/job_serialization_test.rb @@ -65,13 +65,50 @@ class JobSerializationTest < ActiveSupport::TestCase end end - test "serializes enqueued_at with full precision" do + test "serializes and deserializes enqueued_at with full precision" do freeze_time serialized = HelloJob.new.serialize assert_kind_of String, serialized["enqueued_at"] enqueued_at = HelloJob.deserialize(serialized).enqueued_at - assert_equal Time.now.utc, Time.iso8601(enqueued_at) + assert_kind_of Time, enqueued_at + assert_equal Time.now.utc, enqueued_at + end + + test "serializes and deserializes scheduled_at as Time" do + freeze_time + current_time = Time.now + + job = HelloJob.new + job.scheduled_at = current_time + serialized_job = job.serialize + assert_kind_of String, serialized_job["enqueued_at"] + assert_equal current_time.utc.iso8601(9), serialized_job["enqueued_at"] + + deserialized_job = HelloJob.new + deserialized_job.deserialize(serialized_job) + assert_equal current_time, deserialized_job.scheduled_at + + assert_equal job.serialize, deserialized_job.serialize + end + + test "deprecates and coerces numerical scheduled_at attribute to Time when serialized and deserialized" do + freeze_time + current_time = Time.now + + job = HelloJob.new + assert_deprecated(ActiveJob.deprecator) do + job.scheduled_at = current_time.to_f + end + + serialized_job = job.serialize + assert_kind_of String, serialized_job["scheduled_at"] + assert_equal current_time.utc.iso8601(9), serialized_job["scheduled_at"] + + deserialized_job = HelloJob.new + deserialized_job.deserialize(serialized_job) + assert_equal current_time, deserialized_job.scheduled_at + assert_equal job.serialize, deserialized_job.serialize end end diff --git a/activejob/test/cases/logging_test.rb b/activejob/test/cases/logging_test.rb index 2f12b71c71ab0..6669b5ce0852d 100644 --- a/activejob/test/cases/logging_test.rb +++ b/activejob/test/cases/logging_test.rb @@ -107,17 +107,17 @@ def test_globalid_nested_parameter_logging def test_enqueue_job_logging events = subscribed { HelloJob.perform_later "Cristian" } assert_match(/Enqueued HelloJob \(Job ID: .*?\) to .*?:.*Cristian/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue.active_job") + assert_equal("enqueue.active_job", key) end def test_enqueue_job_log_error_when_callback_chain_is_halted events = subscribed { AbortBeforeEnqueueJob.perform_later } assert_match(/Failed enqueuing AbortBeforeEnqueueJob.* a before_enqueue callback halted/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue.active_job") + assert_equal("enqueue.active_job", key) end def test_enqueue_job_log_error_when_error_is_raised_during_callback_chain @@ -128,9 +128,9 @@ def test_enqueue_job_log_error_when_error_is_raised_during_callback_chain end assert_match(/Failed enqueuing AbortBeforeEnqueueJob/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue.active_job") + assert_equal("enqueue.active_job", key) end def test_perform_job_logging @@ -207,9 +207,9 @@ def test_perform_nested_jobs_logging def test_enqueue_at_job_logging events = subscribed { HelloJob.set(wait_until: 24.hours.from_now).perform_later "Cristian" } assert_match(/Enqueued HelloJob \(Job ID: .*\) to .*? at.*Cristian/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue_at.active_job") + assert_equal("enqueue_at.active_job", key) rescue NotImplementedError skip end @@ -217,9 +217,9 @@ def test_enqueue_at_job_logging def test_enqueue_at_job_log_error_when_callback_chain_is_halted events = subscribed { AbortBeforeEnqueueJob.set(wait: 1.second).perform_later } assert_match(/Failed enqueuing AbortBeforeEnqueueJob.* a before_enqueue callback halted/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue_at.active_job") + assert_equal("enqueue_at.active_job", key) end def test_enqueue_at_job_log_error_when_error_is_raised_during_callback_chain @@ -230,21 +230,35 @@ def test_enqueue_at_job_log_error_when_error_is_raised_during_callback_chain end assert_match(/Failed enqueuing AbortBeforeEnqueueJob/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue_at.active_job") + assert_equal("enqueue_at.active_job", key) end def test_enqueue_in_job_logging events = subscribed { HelloJob.set(wait: 2.seconds).perform_later "Cristian" } assert_match(/Enqueued HelloJob \(Job ID: .*\) to .*? at.*Cristian/, @logger.messages) - assert_equal(events.count, 1) + assert_equal(1, events.count) key, * = events.first - assert_equal(key, "enqueue_at.active_job") + assert_equal("enqueue_at.active_job", key) rescue NotImplementedError skip end + def test_enqueue_log_when_enqueue_error_is_set + EnqueueErrorJob.disable_test_adapter + + EnqueueErrorJob.perform_later + assert_match(/Failed enqueuing EnqueueErrorJob to EnqueueError\(default\): ActiveJob::EnqueueError \(There was an error enqueuing the job\)/, @logger.messages) + end + + def test_enqueue_at_log_when_enqueue_error_is_set + EnqueueErrorJob.disable_test_adapter + + EnqueueErrorJob.set(wait: 1.hour).perform_later + assert_match(/Failed enqueuing EnqueueErrorJob to EnqueueError\(default\): ActiveJob::EnqueueError \(There was an error enqueuing the job\)/, @logger.messages) + end + def test_for_tagged_logger_support_is_consistent set_logger ::Logger.new(nil) OverriddenLoggingJob.perform_later "Dummy" diff --git a/activejob/test/cases/queuing_test.rb b/activejob/test/cases/queuing_test.rb index 675496cbcb82a..2413987df33eb 100644 --- a/activejob/test/cases/queuing_test.rb +++ b/activejob/test/cases/queuing_test.rb @@ -5,6 +5,7 @@ require "jobs/enqueue_error_job" require "jobs/multiple_kwargs_job" require "active_support/core_ext/numeric/time" +require "minitest/mock" class QueuingTest < ActiveSupport::TestCase setup do @@ -35,7 +36,7 @@ class QueuingTest < ActiveSupport::TestCase test "job returned by perform_at has the timestamp available" do job = HelloJob.set(wait_until: Time.utc(2014, 1, 1)).perform_later - assert_equal Time.utc(2014, 1, 1).to_f, job.scheduled_at + assert_equal Time.utc(2014, 1, 1), job.scheduled_at rescue NotImplementedError skip end @@ -71,6 +72,19 @@ class QueuingTest < ActiveSupport::TestCase assert_equal ["Jamie says hello", "Job with argument1: John, argument2: 42"], JobBuffer.values.sort end + test "perform_all_later enqueues jobs with schedules" do + scheduled_job_1 = HelloJob.new("Scheduled 2014") + scheduled_job_1.set(wait_until: Time.utc(2014, 1, 1)) + + scheduled_job_2 = HelloJob.new("Scheduled 2015") + scheduled_job_2.scheduled_at = Time.utc(2015, 1, 1) + + ActiveJob.perform_all_later(scheduled_job_1, scheduled_job_2) + assert_equal ["Scheduled 2014 says hello", "Scheduled 2015 says hello"], JobBuffer.values.sort + rescue NotImplementedError + skip + end + test "perform_all_later instrumentation" do jobs = HelloJob.new("Jamie"), HelloJob.new("John") called = false diff --git a/activejob/test/cases/test_helper_test.rb b/activejob/test/cases/test_helper_test.rb index 64fca4d6030cd..f206b98ab1020 100644 --- a/activejob/test/cases/test_helper_test.rb +++ b/activejob/test/cases/test_helper_test.rb @@ -527,7 +527,7 @@ def test_assert_enqueued_with_returns end assert_instance_of LoggingJob, job - assert_in_delta 5.minutes.from_now.to_f, job.scheduled_at, 1 + assert_in_delta 5.minutes.from_now.to_f, job.scheduled_at.to_f, 1 assert_equal "default", job.queue_name assert_equal [1, 2, 3, { keyword: true }], job.arguments end @@ -537,7 +537,7 @@ def test_assert_enqueued_with_with_no_block_returns job = assert_enqueued_with(job: LoggingJob) assert_instance_of LoggingJob, job - assert_in_delta 5.minutes.from_now.to_f, job.scheduled_at, 1 + assert_in_delta 5.minutes.from_now.to_f, job.scheduled_at.to_f, 1 assert_equal "default", job.queue_name assert_equal [1, 2, 3, { keyword: true }], job.arguments end diff --git a/activejob/test/jobs/retry_job.rb b/activejob/test/jobs/retry_job.rb index 8d8c93fa380e4..a1b5a0f13ef08 100644 --- a/activejob/test/jobs/retry_job.rb +++ b/activejob/test/jobs/retry_job.rb @@ -10,7 +10,7 @@ class FirstRetryableErrorOfTwo < StandardError; end class SecondRetryableErrorOfTwo < StandardError; end class LongWaitError < StandardError; end class ShortWaitTenAttemptsError < StandardError; end -class ExponentialWaitTenAttemptsError < StandardError; end +class PolynomialWaitTenAttemptsError < StandardError; end class CustomWaitTenAttemptsError < StandardError; end class CustomCatchError < StandardError; end class DiscardableError < StandardError; end @@ -26,7 +26,7 @@ class RetryJob < ActiveJob::Base retry_on FirstRetryableErrorOfTwo, SecondRetryableErrorOfTwo, attempts: 4 retry_on LongWaitError, wait: 1.hour, attempts: 10 retry_on ShortWaitTenAttemptsError, wait: 1.second, attempts: 10 - retry_on ExponentialWaitTenAttemptsError, wait: :exponentially_longer, attempts: 10 + retry_on PolynomialWaitTenAttemptsError, wait: :polynomially_longer, attempts: 10 retry_on CustomWaitTenAttemptsError, wait: ->(executions) { executions * 2 }, attempts: 10 retry_on(CustomCatchError) { |job, error| JobBuffer.add("Dealt with a job that failed to retry in a custom way after #{job.arguments.second} attempts. Message: #{error.message}") } retry_on(ActiveJob::DeserializationError) { |job, error| JobBuffer.add("Raised #{error.class} for the #{job.executions} time") } @@ -38,7 +38,7 @@ class RetryJob < ActiveJob::Base before_enqueue do |job| if job.arguments.include?(:log_scheduled_at) && job.scheduled_at - JobBuffer.add("Next execution scheduled at #{job.scheduled_at}") + JobBuffer.add("Next execution scheduled at #{job.scheduled_at.to_f}") end end diff --git a/activemodel/CHANGELOG.md b/activemodel/CHANGELOG.md index bd697f8dee7f3..16701b065e7c7 100644 --- a/activemodel/CHANGELOG.md +++ b/activemodel/CHANGELOG.md @@ -1,197 +1,2 @@ -* Add `ActiveModel::Conversion.param_delimiter` to configure delimiter being used in `to_param` - *Nikita Vasilevsky* - -* `undefine_attribute_methods` undefines alias attribute methods along with attribute methods. - - *Nikita Vasilevsky* - -* Error.full_message now strips ":base" from the message. - - *zzak* - -* Add a load hook for `ActiveModel::Model` (named `active_model`) to match the load hook for - `ActiveRecord::Base` and allow for overriding aspects of the `ActiveModel::Model` class. - - *Lewis Buckley* - -* Improve password length validation in ActiveModel::SecurePassword to consider byte size for BCrypt - compatibility. - - The previous password length validation only considered the character count, which may not - accurately reflect the 72-byte size limit imposed by BCrypt. This change updates the validation - to consider both character count and byte size while keeping the character length validation in place. - - ```ruby - user = User.new(password: "a" * 73) # 73 characters - user.valid? # => false - user.errors[:password] # => ["is too long"] - - - user = User.new(password: "あ" * 25) # 25 characters, 75 bytes - user.valid? # => false - user.errors[:password] # => ["is too long"] - ``` - - *ChatGPT*, *Guillermo Iguaran* - -* `has_secure_password` now generates an `#{attribute}_salt` method that returns the salt - used to compute the password digest. The salt will change whenever the password is changed, - so it can be used to create single-use password reset tokens with `generates_token_for`: - - ```ruby - class User < ActiveRecord::Base - has_secure_password - - generates_token_for :password_reset, expires_in: 15.minutes do - password_salt&.last(10) - end - end - ``` - - *Lázaro Nixon* - -* Improve typography of user facing error messages. In English contractions, - the Unicode APOSTROPHE (`U+0027`) is now RIGHT SINGLE QUOTATION MARK - (`U+2019`). For example, "can't be blank" is now "can’t be blank". - - *Jon Dufresne* - -* Add class to `ActiveModel::MissingAttributeError` error message. - - Show which class is missing the attribute in the error message: - - ```ruby - user = User.first - user.pets.select(:id).first.user_id - # => ActiveModel::MissingAttributeError: missing attribute 'user_id' for Pet - ``` - - *Petrik de Heus* - -* Raise `NoMethodError` in `ActiveModel::Type::Value#as_json` to avoid unpredictable - results. - - *Vasiliy Ermolovich* - -* Custom attribute types that inherit from Active Model built-in types and do - not override the `serialize` method will now benefit from an optimization - when serializing attribute values for the database. - - For example, with a custom type like the following: - - ```ruby - class DowncasedString < ActiveModel::Type::String - def cast(value) - super&.downcase - end - end - - ActiveRecord::Type.register(:downcased_string, DowncasedString) - - class User < ActiveRecord::Base - attribute :email, :downcased_string - end - - user = User.new(email: "FooBar@example.com") - ``` - - Serializing the `email` attribute for the database will be roughly twice as - fast. More expensive `cast` operations will likely see greater improvements. - - *Jonathan Hefner* - -* `has_secure_password` now supports password challenges via a - `password_challenge` accessor and validation. - - A password challenge is a safeguard to verify that the current user is - actually the password owner. It can be used when changing sensitive model - fields, such as the password itself. It is different than a password - confirmation, which is used to prevent password typos. - - When `password_challenge` is set, the validation checks that the value's - digest matches the *currently persisted* `password_digest` (i.e. - `password_digest_was`). - - This allows a password challenge to be done as part of a typical `update` - call, just like a password confirmation. It also allows a password - challenge error to be handled in the same way as other validation errors. - - For example, in the controller, instead of: - - ```ruby - password_params = params.require(:password).permit( - :password_challenge, - :password, - :password_confirmation, - ) - - password_challenge = password_params.delete(:password_challenge) - @password_challenge_failed = !current_user.authenticate(password_challenge) - - if !@password_challenge_failed && current_user.update(password_params) - # ... - end - ``` - - You can now write: - - ```ruby - password_params = params.require(:password).permit( - :password_challenge, - :password, - :password_confirmation, - ).with_defaults(password_challenge: "") - - if current_user.update(password_params) - # ... - end - ``` - - And, in the view, instead of checking `@password_challenge_failed`, you can - render an error for the `password_challenge` field just as you would for - other form fields, including utilizing `config.action_view.field_error_proc`. - - *Jonathan Hefner* - -* Support infinite ranges for `LengthValidator`s `:in`/`:within` options - - ```ruby - validates_length_of :first_name, in: ..30 - ``` - - *fatkodima* - -* Add support for beginless ranges to inclusivity/exclusivity validators: - - ```ruby - validates_inclusion_of :birth_date, in: -> { (..Date.today) } - ``` - - *Bo Jeanes* - -* Make validators accept lambdas without record argument - - ```ruby - # Before - validates_comparison_of :birth_date, less_than_or_equal_to: ->(_record) { Date.today } - - # After - validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today } - ``` - - *fatkodima* - -* Fix casting long strings to `Date`, `Time` or `DateTime` - - *fatkodima* - -* Use different cache namespace for proxy calls - - Models can currently have different attribute bodies for the same method - names, leading to conflicts. Adding a new namespace `:active_model_proxy` - fixes the issue. - - *Chris Salzberg* - -Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activemodel/CHANGELOG.md) for previous changes. +Please check [7-1-stable](https://github.com/rails/rails/blob/7-1-stable/activemodel/CHANGELOG.md) for previous changes. diff --git a/activemodel/lib/active_model/attribute_methods.rb b/activemodel/lib/active_model/attribute_methods.rb index 9118c350adcb5..b9582566cdd22 100644 --- a/activemodel/lib/active_model/attribute_methods.rb +++ b/activemodel/lib/active_model/attribute_methods.rb @@ -202,8 +202,10 @@ def attribute_method_affix(*affixes) # person.name_short? # => true # person.nickname_short? # => true def alias_attribute(new_name, old_name) - self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s) - self.local_attribute_aliases = local_attribute_aliases.merge(new_name.to_s => old_name.to_s) + old_name = old_name.to_s + new_name = new_name.to_s + self.attribute_aliases = attribute_aliases.merge(new_name => old_name) + aliases_by_attribute_name[old_name] << new_name eagerly_generate_alias_attribute_methods(new_name, old_name) end @@ -282,7 +284,12 @@ def attribute_alias(name) # end def define_attribute_methods(*attr_names) ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner| - attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) } + attr_names.flatten.each do |attr_name| + define_attribute_method(attr_name, _owner: owner) + aliases_by_attribute_name[attr_name.to_s].each do |aliased_name| + generate_alias_attribute_methods owner, aliased_name, attr_name + end + end end end @@ -365,13 +372,11 @@ def undefine_attribute_methods attribute_method_patterns_cache.clear end - def local_attribute_aliases # :nodoc: - @local_attribute_aliases ||= {} + def aliases_by_attribute_name # :nodoc: + @aliases_by_attribute_name ||= Hash.new { |h, k| h[k] = [] } end private - attr_writer :local_attribute_aliases # :nodoc: - def inherited(base) # :nodoc: super base.class_eval do diff --git a/activemodel/lib/active_model/conversion.rb b/activemodel/lib/active_model/conversion.rb index 0a03336555db5..c6f4b2fc898ad 100644 --- a/activemodel/lib/active_model/conversion.rb +++ b/activemodel/lib/active_model/conversion.rb @@ -108,7 +108,9 @@ module ClassMethods # :nodoc: # Provide a class level cache for #to_partial_path. This is an # internal method and should not be accessed directly. def _to_partial_path # :nodoc: - @_to_partial_path ||= begin + @_to_partial_path ||= if respond_to?(:model_name) + "#{model_name.collection}/#{model_name.element}" + else element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name)) collection = ActiveSupport::Inflector.tableize(name) "#{collection}/#{element}" diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb index d9b83300e6502..dd981e51949a5 100644 --- a/activemodel/lib/active_model/errors.rb +++ b/activemodel/lib/active_model/errors.rb @@ -284,7 +284,7 @@ def group_by_attribute # # person.errors.add(:name, :blank) # person.errors.messages - # # => {:name=>["can’t be blank"]} + # # => {:name=>["can't be blank"]} # # person.errors.add(:name, :too_long, count: 25) # person.errors.messages @@ -332,7 +332,7 @@ def add(attribute, type = :invalid, **options) # # person.errors.add :name, :blank # person.errors.added? :name, :blank # => true - # person.errors.added? :name, "can’t be blank" # => true + # person.errors.added? :name, "can't be blank" # => true # # If the error requires options, then it returns +true+ with # the correct options, or +false+ with incorrect or missing options. @@ -385,7 +385,7 @@ def of_kind?(attribute, type = :invalid) # # person = Person.create(address: '123 First St.') # person.errors.full_messages - # # => ["Name is too short (minimum is 5 characters)", "Name can’t be blank", "Email can’t be blank"] + # # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"] def full_messages @errors.map(&:full_message) end @@ -400,7 +400,7 @@ def full_messages # # person = Person.create() # person.errors.full_messages_for(:name) - # # => ["Name is too short (minimum is 5 characters)", "Name can’t be blank"] + # # => ["Name is too short (minimum is 5 characters)", "Name can't be blank"] def full_messages_for(attribute) where(attribute).map(&:full_message).freeze end @@ -414,7 +414,7 @@ def full_messages_for(attribute) # # person = Person.create() # person.errors.messages_for(:name) - # # => ["is too short (minimum is 5 characters)", "can’t be blank"] + # # => ["is too short (minimum is 5 characters)", "can't be blank"] def messages_for(attribute) where(attribute).map(&:message) end @@ -487,7 +487,7 @@ def normalize_arguments(attribute, type, **options) # person = Person.new # person.name = nil # person.valid? - # # => ActiveModel::StrictValidationFailed: Name can’t be blank + # # => ActiveModel::StrictValidationFailed: Name can't be blank class StrictValidationFailed < StandardError end diff --git a/activemodel/lib/active_model/gem_version.rb b/activemodel/lib/active_model/gem_version.rb index 22e24583bd366..d1d8f256d1d71 100644 --- a/activemodel/lib/active_model/gem_version.rb +++ b/activemodel/lib/active_model/gem_version.rb @@ -8,7 +8,7 @@ def self.gem_version module VERSION MAJOR = 7 - MINOR = 1 + MINOR = 2 TINY = 0 PRE = "alpha" diff --git a/activemodel/lib/active_model/locale/en.yml b/activemodel/lib/active_model/locale/en.yml index e96ce8ee18c30..c6a036359f863 100644 --- a/activemodel/lib/active_model/locale/en.yml +++ b/activemodel/lib/active_model/locale/en.yml @@ -10,10 +10,10 @@ en: inclusion: "is not included in the list" exclusion: "is reserved" invalid: "is invalid" - confirmation: "doesn’t match %{attribute}" + confirmation: "doesn't match %{attribute}" accepted: "must be accepted" - empty: "can’t be empty" - blank: "can’t be blank" + empty: "can't be empty" + blank: "can't be blank" present: "must be blank" too_long: one: "is too long (maximum is 1 character)" diff --git a/activemodel/lib/active_model/secure_password.rb b/activemodel/lib/active_model/secure_password.rb index 965b38b78cec7..b6bf24ab8688c 100644 --- a/activemodel/lib/active_model/secure_password.rb +++ b/activemodel/lib/active_model/secure_password.rb @@ -57,7 +57,7 @@ module ClassMethods # # user.save # => false, password required # user.password = "vr00m" - # user.save # => false, confirmation doesn’t match + # user.save # => false, confirmation doesn't match # user.password_confirmation = "vr00m" # user.save # => true # diff --git a/activemodel/lib/active_model/validations.rb b/activemodel/lib/active_model/validations.rb index 6d3ad5d4fc3a5..40e96bc83e088 100644 --- a/activemodel/lib/active_model/validations.rb +++ b/activemodel/lib/active_model/validations.rb @@ -326,7 +326,7 @@ def initialize_dup(other) # :nodoc: # # person = Person.new # person.valid? # => false - # person.errors # => #<%= html_escape_once("this & that & the other") %>
- ``` - - Before this change, that would be double-escaped and render as: - - ```html -this & that & the other
- ``` - - After this change, it renders correctly as: - - ```html -this & that & the other
- ``` - - Fixes #48256 - - *Mike Dalessio* - -* Deprecate `SafeBuffer#clone_empty`. - - This method has not been used internally since Rails 4.2.0. - - *Mike Dalessio* - -* `MessageEncryptor`, `MessageVerifier`, and `config.active_support.message_serializer` - now accept `:message_pack` and `:message_pack_allow_marshal` as serializers. - These serializers require the [`msgpack` gem](https://rubygems.org/gems/msgpack) - (>= 1.7.0). - - The Message Pack format can provide improved performance and smaller payload - sizes. It also supports round-tripping some Ruby types that are not supported - by JSON. For example: - - ```ruby - verifier = ActiveSupport::MessageVerifier.new("secret") - data = [{ a: 1 }, { b: 2 }.with_indifferent_access, 1.to_d, Time.at(0, 123)] - message = verifier.generate(data) - - # BEFORE with config.active_support.message_serializer = :json - verifier.verified(message) - # => [{"a"=>1}, {"b"=>2}, "1.0", "1969-12-31T18:00:00.000-06:00"] - verifier.verified(message).map(&:class) - # => [Hash, Hash, String, String] - - # AFTER with config.active_support.message_serializer = :message_pack - verifier.verified(message) - # => [{:a=>1}, {"b"=>2}, 0.1e1, 1969-12-31 18:00:00.000123 -0600] - verifier.verified(message).map(&:class) - # => [Hash, ActiveSupport::HashWithIndifferentAccess, BigDecimal, Time] - ``` - - The `:message_pack` serializer can fall back to deserializing with - `ActiveSupport::JSON` when necessary, and the `:message_pack_allow_marshal` - serializer can fall back to deserializing with `Marshal` as well as - `ActiveSupport::JSON`. Additionally, the `:marshal`, `:json`, and - `:json_allow_marshal` serializers can now fall back to deserializing with - `ActiveSupport::MessagePack` when necessary. These behaviors ensure old - messages can still be read so that migration is easier. - - *Jonathan Hefner* - -* A new `7.1` cache format is available which includes an optimization for - bare string values such as view fragments. - - The `7.1` cache format is used by default for new apps, and existing apps - can enable the format by setting `config.load_defaults 7.1` or by setting - `config.active_support.cache_format_version = 7.1` in `config/application.rb` - or a `config/environments/*.rb` file. - - Cache entries written using the `6.1` or `7.0` cache formats can be read - when using the `7.1` format. To perform a rolling deploy of a Rails 7.1 - upgrade, wherein servers that have not yet been upgraded must be able to - read caches from upgraded servers, leave the cache format unchanged on the - first deploy, then enable the `7.1` cache format on a subsequent deploy. - - *Jonathan Hefner* - -* Active Support cache stores can now use a preconfigured serializer based on - `ActiveSupport::MessagePack` via the `:serializer` option: - - ```ruby - config.cache_store = :redis_cache_store, { serializer: :message_pack } - ``` - - The `:message_pack` serializer can reduce cache entry sizes and improve - performance, but requires the [`msgpack` gem](https://rubygems.org/gems/msgpack) - (>= 1.7.0). - - The `:message_pack` serializer can read cache entries written by the default - serializer, and the default serializer can now read entries written by the - `:message_pack` serializer. These behaviors make it easy to migrate between - serializer without invalidating the entire cache. - - *Jonathan Hefner* - -* `Object#deep_dup` no longer duplicate named classes and modules. - - Before: - - ```ruby - hash = { class: Object, module: Kernel } - hash.deep_dup # => {:class=>#- These are the new guides for Rails 7.1 based on <%= @version %>. + These are the new guides for Rails 7.2 based on <%= @version %>. These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together.
<% end %>The guides for earlier releases: +Rails 7.1, Rails 7.0, Rails 6.1, Rails 6.0, diff --git a/guides/source/action_controller_overview.md b/guides/source/action_controller_overview.md index c31110fc2dbb7..a7b9ee4244584 100644 --- a/guides/source/action_controller_overview.md +++ b/guides/source/action_controller_overview.md @@ -186,6 +186,34 @@ In this case, when a user opens the URL `/clients/active`, `params[:status]` wil [`controller_name`]: https://api.rubyonrails.org/classes/ActionController/Metal.html#method-i-controller_name [`action_name`]: https://api.rubyonrails.org/classes/AbstractController/Base.html#method-i-action_name +### Composite Key Parameters + +Composite key parameters contain multiple values in one parameter. For this reason, we need to be able to extract each value and pass them to Active Record. We can leverage the `extract_value` method for this use-case. + +Given the following controller: + +```ruby +class BooksController < ApplicationController + def show + # Extract the composite ID value from URL parameters. + id = params.extract_value(:id) + # Find the book using the composite ID. + @book = Book.find(id) + # use the default rendering behaviour to render the show view. + end +end +``` + +And the following route: + +```ruby +get '/books/:id', to: 'books#show' +``` + +When a user opens the URL `/books/4_2`, the controller will extract the composite +key value `["4", "2"]` and pass it to `Book.find` to render the right record in the view. +The `extract_value` method may be used to extract arrays out of any delimited parameters. + ### `default_url_options` You can set global default parameters for URL generation by defining a method called `default_url_options` in your controller. Such a method must return a hash with the desired defaults, whose keys must be symbols: diff --git a/guides/source/action_mailer_basics.md b/guides/source/action_mailer_basics.md index 796eff175fdc3..dca63d10e5771 100644 --- a/guides/source/action_mailer_basics.md +++ b/guides/source/action_mailer_basics.md @@ -777,7 +777,38 @@ class UserMailer < ApplicationMailer end ``` -* You could use an `after_delivery` to record the delivery of the message. +* You could use an `after_deliver` to record the delivery of the message. It + also allows observer/interceptor-like behaviors, but with access to the full + mailer context. + +```ruby +class UserMailer < ApplicationMailer + after_deliver :mark_delivered + before_deliver :sandbox_staging + after_deliver :observe_delivery + + def feedback_message + @feedback = params[:feedback] + end + + private + def mark_delivered + params[:feedback].touch(:delivered_at) + end + + # An Interceptor alternative. + def sandbox_staging + message.to = ['sandbox@example.com'] if Rails.env.staging? + end + + # A callback has more context than the comparable Observer example. + def observe_delivery + EmailDelivery.log(message, self.class, action_name, params) + end +end +``` + + * Mailer callbacks abort further processing if body is set to a non-nil value. `before_deliver` can abort with `throw :abort`. diff --git a/guides/source/action_view_helpers.md b/guides/source/action_view_helpers.md index 41666cbdb04d0..3bd236a584858 100644 --- a/guides/source/action_view_helpers.md +++ b/guides/source/action_view_helpers.md @@ -192,7 +192,7 @@ A method for caching fragments of a view rather than an entire action or page. T ```erb <% cache do %> - <%= render "shared/footer" %> + <%= render "application/footer" %> <% end %> ``` @@ -468,6 +468,9 @@ url_for @profile url_for [ @hotel, @booking, page: 2, line: 3 ] # => /hotels/1/bookings/1?line=3&page=2 + +url_for @post # given a composite primary key [:blog_id, :id] +# => /posts/1_2 ``` #### link_to @@ -481,6 +484,9 @@ when passing models to `link_to`. ```ruby link_to "Profile", @profile # => Profile + +link_to "Book", @book # given a composite primary key [:author_id, :id] +# => Book ``` You can use a block as well if your link target can't fit in the name parameter. ERB example: diff --git a/guides/source/action_view_overview.md b/guides/source/action_view_overview.md index fc2086894ad84..9da2576a22174 100644 --- a/guides/source/action_view_overview.md +++ b/guides/source/action_view_overview.md @@ -197,17 +197,17 @@ To render a partial as part of a view, you use the `render` method within the vi This will render a file named `_menu.html.erb` at that point within the view that is being rendered. Note the leading underscore character: partials are named with a leading underscore to distinguish them from regular views, even though they are referred to without the underscore. This holds true even when you're pulling in a partial from another folder: ```erb -<%= render "shared/menu" %> +<%= render "application/menu" %> ``` -That code will pull in the partial from `app/views/shared/_menu.html.erb`. +That code will pull in the partial from `app/views/application/_menu.html.erb`. ### Using Partials to Simplify Views One way to use partials is to treat them as the equivalent of subroutines; a way to move details out of a view so that you can grasp what's going on more easily. For example, you might have a view that looks like this: ```html+erb -<%= render "shared/ad_banner" %> +<%= render "application/ad_banner" %>
Here are a few of our fine products:
-... +<%# ... %> -<%= render "shared/footer" %> +<%= render "application/footer" %> ``` Here, the `_ad_banner.html.erb` and `_footer.html.erb` partials could contain @@ -1133,7 +1134,7 @@ definitions for several similar resources: * `users/index.html.erb` ```html+erb - <%= render "shared/search_filters", search: @q do |form| %> + <%= render "application/search_filters", search: @q do |form| %>Name contains: <%= form.text_field :name_contains %>
@@ -1143,14 +1144,14 @@ definitions for several similar resources: * `roles/index.html.erb` ```html+erb - <%= render "shared/search_filters", search: @q do |form| %> + <%= render "application/search_filters", search: @q do |form| %>Title contains: <%= form.text_field :title_contains %>
<% end %> ``` -* `shared/_search_filters.html.erb` +* `application/_search_filters.html.erb` ```html+erb <%= form_with model: search do |form| %> diff --git a/guides/source/maintenance_policy.md b/guides/source/maintenance_policy.md index 3519adc8c16d7..4d1f87998f9a9 100644 --- a/guides/source/maintenance_policy.md +++ b/guides/source/maintenance_policy.md @@ -53,7 +53,7 @@ For unsupported series, bug fixes may coincidentally land in a stable branch, but won't be released in an official version. It is recommended to point your application at the stable branch using Git for unsupported versions. -**Currently included series:** `7.1.Z`. +**Currently included series:** `7.2.Z`. Security Issues --------------- @@ -78,7 +78,7 @@ there could be breaking changes in the security release. A security release should only contain the changes needed to ensure the app is secure so that it's easier for applications to remain upgraded. -**Currently included series:** `7.1.Z`, `7.0.Z`, `6.1.Z`. +**Currently included series:** `7.2.Z`, `7.1.Z`. Severe Security Issues ---------------------- @@ -87,7 +87,7 @@ For severe security issues all releases in the current major series, and also th last release in the previous major series will receive patches and new versions. The classification of the security issue is judged by the core team. -**Currently included series:** `7.1.Z`, `7.0.Z`, `6.1.Z`. +**Currently included series:** `7.2.Z`, `7.1.Z`, `7.0.Z`, `6.1.Z`. Unsupported Release Series -------------------------- diff --git a/guides/source/ruby_on_rails_guides_guidelines.md b/guides/source/ruby_on_rails_guides_guidelines.md index 91321cba27b28..24b5061ff3510 100644 --- a/guides/source/ruby_on_rails_guides_guidelines.md +++ b/guides/source/ruby_on_rails_guides_guidelines.md @@ -92,6 +92,10 @@ https://api.rubyonrails.org/v5.1.0/classes/ActionDispatch/Response.html Please don't link to `edgeapi.rubyonrails.org` manually. +Column Wrapping +--------------- + +Do not reformat old guides just to wrap columns. But new sections and guides should wrap at 80 columns. API Documentation Guidelines ---------------------------- diff --git a/guides/source/security.md b/guides/source/security.md index 41271e3ac587c..2a5e6b8ad7b33 100644 --- a/guides/source/security.md +++ b/guides/source/security.md @@ -527,7 +527,7 @@ INFO: _A common pitfall in Ruby's regular expressions is to match the string's b Ruby uses a slightly different approach than many other languages to match the end and the beginning of a string. That is why even many Ruby and Rails books get this wrong. So how is this a security threat? Say you wanted to loosely validate a URL field and you used a simple regular expression like this: ```ruby - /^https?:\/\/[^\n]+$/i +/^https?:\/\/[^\n]+$/i ``` This may work fine in some languages. However, _in Ruby `^` and `$` match the **line** beginning and line end_. And thus a URL like this passes the filter without problems: @@ -541,7 +541,7 @@ http://hi.com This URL passes the filter because the regular expression matches - the second line, the rest does not matter. Now imagine we had a view that showed the URL like this: ```ruby - link_to "Homepage", @user.homepage +link_to "Homepage", @user.homepage ``` The link looks innocent to visitors, but when it's clicked, it will execute the JavaScript function "exploit_code" or any other JavaScript the attacker provides. @@ -549,14 +549,14 @@ The link looks innocent to visitors, but when it's clicked, it will execute the To fix the regular expression, `\A` and `\z` should be used instead of `^` and `$`, like so: ```ruby - /\Ahttps?:\/\/[^\n]+\z/i +/\Ahttps?:\/\/[^\n]+\z/i ``` Since this is a frequent mistake, the format validator (validates_format_of) now raises an exception if the provided regular expression starts with ^ or ends with $. If you do need to use ^ and $ instead of \A and \z (which is rare), you can set the :multiline option to true, like so: ```ruby - # content should include a line "Meanwhile" anywhere in the string - validates :content, format: { with: /^Meanwhile$/, multiline: true } +# content should include a line "Meanwhile" anywhere in the string +validates :content, format: { with: /^Meanwhile$/, multiline: true } ``` Note that this only protects you against the most common mistake when using the format validator - you always need to keep in mind that ^ and $ match the **line** beginning and line end in Ruby, and not the beginning and end of a string. @@ -579,7 +579,7 @@ This is alright for some web applications, but certainly not if the user is not Depending on your web application, there will be many more parameters the user can tamper with. As a rule of thumb, _no user input data is secure, until proven otherwise, and every parameter from the user is potentially manipulated_. -Don't be fooled by security by obfuscation and JavaScript security. Developer tools let you review and change every form's hidden fields. _JavaScript can be used to validate user input data, but certainly not to prevent attackers from sending malicious requests with unexpected values_. The Firebug addon for Mozilla Firefox logs every request and may repeat and change them. That is an easy way to bypass any JavaScript validations. And there are even client-side proxies that allow you to intercept any request and response from and to the Internet. +Don't be fooled by security by obfuscation and JavaScript security. Developer tools let you review and change every form's hidden fields. _JavaScript can be used to validate user input data, but certainly not to prevent attackers from sending malicious requests with unexpected values_. DevTools log every request and may repeat and change them. That is an easy way to bypass any JavaScript validations. And there are even client-side proxies that allow you to intercept any request and response from and to the Internet. Injection --------- @@ -1143,7 +1143,7 @@ browser automatically upgrades to HTTPS for current and future connections. The header is added to the response when enabling the `force_ssl` option: ```ruby - config.force_ssl = true +config.force_ssl = true ``` [`Strict-Transport-Security`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security diff --git a/guides/source/testing.md b/guides/source/testing.md index 94e90ed9ebdbc..a10ceb964ec30 100644 --- a/guides/source/testing.md +++ b/guides/source/testing.md @@ -1691,6 +1691,155 @@ assert_select_email do end ``` +Testing View Partials +--------------------- + +Partial templates - usually called "partials" - are another device for breaking the rendering process into more manageable chunks. With partials, you can extract pieces of code from your templates to separate files and reuse them throughout your templates. + +View tests provide an opportunity to test that partials render content the way you expect. View partial tests reside in `test/views/` and inherit from `ActionView::TestCase`. + +To render a partial, call `render` like you would in a template. The content is +available through the test-local `#rendered` method: + +```ruby +class ArticlePartialTest < ActionView::TestCase + test "renders a link to itself" do + article = Article.create! title: "Hello, world" + + render "articles/article", article: article + + assert_includes rendered, article.title + end +end +``` + +Tests that inherit from `ActionView::TestCase` also have access to [`assert_select`](#testing-views) and the [other additional view-based assertions](#additional-view-based-assertions) provided by [rails-dom-testing][]: + +```ruby +test "renders a link to itself" do + article = Article.create! title: "Hello, world" + + render "articles/article", article: article + + assert_select "a[href=?]", article_url(article), text: article.title +end +``` + +In order to integrate with [rails-dom-testing][], tests that inherit from +`ActionView::TestCase` declare a `document_root_element` method that returns the +rendered content as an instance of a +[Nokogiri::XML::Node](https://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/Node): + +```ruby +test "renders a link to itself" do + article = Article.create! title: "Hello, world" + + render "articles/article", article: article + anchor = document_root_element.at("a") + + assert_equal article.name, anchor.text + assert_equal article_url(article), anchor["href"] +end +``` + +If your application uses Ruby >= 3.0 or higher, depends on [Nokogiri >= 1.14.0](https://github.com/sparklemotion/nokogiri/releases/tag/v1.14.0) or +higher, and depends on [Minitest >= >5.18.0](https://github.com/minitest/minitest/blob/v5.18.0/History.rdoc#5180--2023-03-04-), +`document_root_element` supports [Ruby's Pattern Matching](https://docs.ruby-lang.org/en/master/syntax/pattern_matching_rdoc.html): + +```ruby +test "renders a link to itself" do + article = Article.create! title: "Hello, world" + + render "articles/article", article: article + anchor = document_root_element.at("a") + + assert_pattern do + anchor => { content: article.title, attributes: [{ name: "href", value: article_url(article) }] } + end +end +``` + +If you'd like to access the same [Capybara-powered Assertions](https://rubydoc.info/github/teamcapybara/capybara/master/Capybara/Minitest/Assertions) +that your [Functional and System Testing](#functional-and-system-testing) tests +utilize, you can define a base class that inherits from `ActionView::TestCase` +and transforms the `document_root_element` into a `page` method: + +```ruby +# test/view_partial_test_case.rb + +require "test_helper" +require "capybara/minitest" + +class ViewPartialTestCase < ActionView::TestCase + include Capybara::Minitest::Assertions + + def page + Capybara.string(document_root_element) + end +end + +# test/views/article_partial_test.rb + +require "view_partial_test_case" + +class ArticlePartialTest < ViewPartialTestCase + test "renders a link to itself" do + article = Article.create! title: "Hello, world" + + render "articles/article", article: article + + assert_link article.title, href: article_url(article) + end +end +``` + +Starting in Action View version 7.1, the `#rendered` helper method returns an +object capable of parsing the view partial's rendered content. + +To transform the `String` content returned by the `#rendered` method into an +object, define a parser by calling `.register_parser`. Calling +`.register_parser :rss` defines a `#rendered.rss` helper method. For example, +to parse rendered [RSS content][] into an object with `#rendered.rss`, register +a call to `RSS::Parser.parse`: + +```ruby +register_parser :rss, -> rendered { RSS::Parser.parse(rendered) } + +test "renders RSS" do + article = Article.create!(title: "Hello, world") + + render formats: :rss, partial: article + + assert_equal "Hello, world", rendered.rss.items.last.title +end +``` + +By default, `ActionView::TestCase` defines a parser for: + +* `:html` - returns an instance of [Nokogiri::XML::Node](https://nokogiri.org/rdoc/Nokogiri/XML/Node.html) +* `:json` - returns an instance of [ActiveSupport::HashWithIndifferentAccess](https://edgeapi.rubyonrails.org/classes/ActiveSupport/HashWithIndifferentAccess.html) + +```ruby +test "renders HTML" do + article = Article.create!(title: "Hello, world") + + render partial: "articles/article", locals: { article: article } + + assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } } +end + +test "renders JSON" do + article = Article.create!(title: "Hello, world") + + render formats: :json, partial: "articles/article", locals: { article: article } + + assert_pattern { rendered.json => { title: "Hello, world" } } +end +``` + +[rails-dom-testing]: https://github.com/rails/rails-dom-testing +[RSS content]: https://www.rssboard.org/rss-specification + Testing Helpers --------------- diff --git a/guides/source/upgrading_ruby_on_rails.md b/guides/source/upgrading_ruby_on_rails.md index 28911d93d2c31..20e86e90af42d 100644 --- a/guides/source/upgrading_ruby_on_rails.md +++ b/guides/source/upgrading_ruby_on_rails.md @@ -44,7 +44,7 @@ Repeat this process until you reach your target Rails version. To move between versions: 1. Change the Rails version number in the `Gemfile` and run `bundle update`. -2. Change the versions for Rails JavaScript packages in `package.json` and run `yarn install`, if running on Webpacker. +2. Change the versions for Rails JavaScript packages in `package.json` and run `bin/rails javascript:install` if running jsbundling-rails 3. Run the [Update task](#the-update-task). 4. Run your tests. @@ -63,7 +63,7 @@ $ bin/rails app:update conflict config/application.rb Overwrite /myapp/config/application.rb? (enter "h" for help) [Ynaqdh] force config/application.rb - create config/initializers/new_framework_defaults_7_0.rb + create config/initializers/new_framework_defaults_7_2.rb ... ``` @@ -75,18 +75,100 @@ The new Rails version might have different configuration defaults than the previ To allow you to upgrade to new defaults one by one, the update task has created a file `config/initializers/new_framework_defaults_X.Y.rb` (with the desired Rails version in the filename). You should enable the new configuration defaults by uncommenting them in the file; this can be done gradually over several deployments. Once your application is ready to run with new defaults, you can remove this file and flip the `config.load_defaults` value. +Upgrading from Rails 7.1 to Rails 7.2 +------------------------------------- + +For more information on changes made to Rails 7.2 please see the [release notes](7_2_release_notes.html). + Upgrading from Rails 7.0 to Rails 7.1 ------------------------------------- For more information on changes made to Rails 7.1 please see the [release notes](7_1_release_notes.html). -### Autoloaded paths are no longer in load path +### Autoloaded paths are no longer in $LOAD_PATH + +Starting from Rails 7.1, the directories managed by the autoloaders are no +longer added to `$LOAD_PATH`. This means it won't be possible to load their +files with a manual `require` call, which shouldn't be done anyway. + +Reducing the size of `$LOAD_PATH` speeds up `require` calls for apps not using +`bootsnap`, and reduces the size of the `bootsnap` cache for the others. + +If you'd like to have these paths still in `$LOAD_PATH`, you can opt-in: + +```ruby +config.add_autoload_paths_to_load_path = true +``` + +but we discourage doing so, classes and modules in the autoload paths are meant +to be autoloaded. That is, just reference them. + +The `lib` directory is not affected by this flag, it is added to `$LOAD_PATH` +always. + +### config.autoload_lib and config.autoload_lib_once -Starting from Rails 7.1, all paths managed by the autoloader will no longer be added to `$LOAD_PATH`. -This means it won't be possible to load them with a manual `require` call, the class or module can be referenced instead. +If your application does not have `lib` in the autoload or autoload once paths, +please skip this section. You can find that out by inspecting the output of -Reducing the size of `$LOAD_PATH` speed-up `require` calls for apps not using `bootsnap`, and reduce the -size of the `bootsnap` cache for the others. +```bash +# Print autoload paths. +$ bin/rails runner 'pp Rails.autoloaders.main.dirs' + +# Print autoload once paths. +$ bin/rails runner 'pp Rails.autoloaders.once.dirs' +``` + +If your application already has `lib` in the autoload paths, normally there is +configuration in `config/application.rb` that looks something like + +```ruby +# Autoload lib, but do not eager load it (maybe overlooked). +config.autoload_paths << config.root.join("lib") +``` + +or + +```ruby +# Autoload and also eager load lib. +config.autoload_paths << config.root.join("lib") +config.eager_load_paths << config.root.join("lib") +``` + +or + +```ruby +# Same, because all eager load paths become autoload paths too. +config.eager_load_paths << config.root.join("lib") +``` + +That still works, but it is recommended to replace those lines with the more +concise + +```ruby +config.autoload_lib(ignore: %w(assets tasks)) +``` + +Please, add to the `ignore` list any other `lib` subdirectories that do not +contain `.rb` files, or that should not be reloaded or eager loaded. For +example, if your application has `lib/templates`, `lib/generators`, or +`lib/middleware`, you'd add their name relative to `lib`: + +```ruby +config.autoload_lib(ignore: %w(assets tasks templates generators middleware)) +``` + +With that one-liner, the (non-ignored) code in `lib` will be also eager loaded +if `config.eager_load` is `true` (the default in `production` mode). This is +normally what you want, but if `lib` was not added to the eager load paths +before and you still want it that way, please opt-out: + +```ruby +Rails.autoloaders.main.do_not_eager_load(config.root.join("lib")) +``` + +The method `config.autoload_lib_once` is the analogous one if the application +had `lib` in `config.autoload_once_paths`. ### `ActiveStorage::BaseController` no longer includes the streaming concern @@ -162,6 +244,19 @@ I18n.t("missing.key") # didn't raise in 7.0, doesn't raise in 7.1 Alternatively, you can customise the `I18n.exception_handler`. See the [i18n guide](https://guides.rubyonrails.org/v7.1/i18n.html#using-different-exception-handlers) for more information. +`AbstractController::Translation.raise_on_missing_translations` has been removed. This was a private API, if you were +relying on it you should migrate to `config.i18n.raise_on_missing_translations` or to a custom exception handler. + +### `bin/rails test` now runs `test:prepare` task + +When running tests via `bin/rails test`, the `rake test:prepare` task will run before tests run. If you've enhanced +the `test:prepare` task, your enhancements will run before your tests. `tailwindcss-rails`, `jsbundling-rails`, and `cssbundling-rails` +enhance this task, as do other third party gems. + +See the [Testing Rails Applications](https://edgeguides.rubyonrails.org/testing.html#running-tests-in-continuous-integration-ci) guide for more information. + +If you run a single file's tests (`bin/rails test test/models/user_test.rb`), `test:prepare` will not run before it. + Upgrading from Rails 6.1 to Rails 7.0 ------------------------------------- @@ -2292,10 +2387,10 @@ Rails 4.0 no longer supports loading plugins from `vendor/plugins`. You must rep * Rails 4.0 requires that scopes use a callable object such as a Proc or lambda: ```ruby - scope :active, where(active: true) + scope :active, where(active: true) - # becomes - scope :active, -> { where active: true } + # becomes + scope :active, -> { where active: true } ``` * Rails 4.0 has deprecated `ActiveRecord::Fixtures` in favor of `ActiveRecord::FixtureSet`. @@ -2356,9 +2451,9 @@ Rails 4.0 extracted Active Resource to its own gem. If you still need the featur * Rails 4.0 introduces `ActiveSupport::KeyGenerator` and uses this as a base from which to generate and verify signed cookies (among other things). Existing signed cookies generated with Rails 3.x will be transparently upgraded if you leave your existing `secret_token` in place and add the new `secret_key_base`. ```ruby - # config/initializers/secret_token.rb - Myapp::Application.config.secret_token = 'existing secret token' - Myapp::Application.config.secret_key_base = 'new secret key base' + # config/initializers/secret_token.rb + Myapp::Application.config.secret_token = 'existing secret token' + Myapp::Application.config.secret_key_base = 'new secret key base' ``` Please note that you should wait to set `secret_key_base` until you have 100% of your userbase on Rails 4.x and are reasonably sure you will not need to rollback to Rails 3.x. This is because cookies signed based on the new `secret_key_base` in Rails 4.x are not backwards compatible with Rails 3.x. You are free to leave your existing `secret_token` in place, not set the new `secret_key_base`, and ignore the deprecation warnings until you are reasonably sure that your upgrade is otherwise complete. @@ -2422,14 +2517,14 @@ Rails 4.0 extracted Active Resource to its own gem. If you still need the featur * Rails 4.0 requires that routes using `match` must specify the request method. For example: ```ruby - # Rails 3.x - match '/' => 'root#index' + # Rails 3.x + match '/' => 'root#index' - # becomes - match '/' => 'root#index', via: :get + # becomes + match '/' => 'root#index', via: :get - # or - get '/' => 'root#index' + # or + get '/' => 'root#index' ``` * Rails 4.0 has removed `ActionDispatch::BestStandardsSupport` middleware, `` already triggers standards mode per https://msdn.microsoft.com/en-us/library/jj676915(v=vs.85).aspx and ChromeFrame header has been moved to `config.action_dispatch.default_headers`. @@ -2446,10 +2541,10 @@ Rails 4.0 extracted Active Resource to its own gem. If you still need the featur * Rails 4.0 allows configuration of HTTP headers by setting `config.action_dispatch.default_headers`. The defaults are as follows: ```ruby - config.action_dispatch.default_headers = { - 'X-Frame-Options' => 'SAMEORIGIN', - 'X-XSS-Protection' => '1; mode=block' - } + config.action_dispatch.default_headers = { + 'X-Frame-Options' => 'SAMEORIGIN', + 'X-XSS-Protection' => '1; mode=block' + } ``` Please note that if your application is dependent on loading certain pages in a `` or `