Merge branch 'main' into structurally-compatible

kaspth · web-flow · commit 845280a8f85f · 2021-08-04T17:23:07.000+02:00
diff --git a/Gemfile.lock b/Gemfile.lock
@@ -81,7 +81,7 @@ PATH
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
+      zeitwerk (~> 2.5.0.beta)
     rails (7.0.0.alpha)
       actioncable (= 7.0.0.alpha)
       actionmailbox (= 7.0.0.alpha)
@@ -522,7 +522,7 @@ GEM
     websocket-extensions (0.1.5)
     xpath (3.2.0)
       nokogiri (~> 1.8)
-    zeitwerk (2.4.2)
+    zeitwerk (2.5.0.beta)
 
 PLATFORMS
   ruby
diff --git a/actionpack/lib/action_dispatch/journey/gtg/transition_table.rb b/actionpack/lib/action_dispatch/journey/gtg/transition_table.rb
@@ -11,7 +11,7 @@ class TransitionTable # :nodoc:
         attr_reader :memos
 
         DEFAULT_EXP = /[^.\/?]+/
-        DEFAULT_EXP_ANCHORED = Regexp.new(/\A#{DEFAULT_EXP}\Z/)
+        DEFAULT_EXP_ANCHORED = /\A#{DEFAULT_EXP}\Z/
 
         def initialize
           @stdparam_states = {}
@@ -165,7 +165,11 @@ def []=(from, to, sym)
           case sym
           when Regexp
             # we must match the whole string to a token boundary
-            sym = Regexp.new(/\A#{sym}\Z/)
+            if sym == DEFAULT_EXP
+              sym = DEFAULT_EXP_ANCHORED
+            else
+              sym = /\A#{sym}\Z/
+            end
           when Symbol
             # account for symbols in the constraints the same as strings
             sym = sym.to_s
diff --git a/actionview/CHANGELOG.md b/actionview/CHANGELOG.md
@@ -1,3 +1,7 @@
+*   Add `caching?` helper that returns whether the current code path is being cached and `unacheable!` to denote helper methods that can't participate in fragment caching.
+
+    *Ben Toews*, *John Hawthorn*, *Kasper Timm Hansen*, *Joel Hawksley*
+
 *   Add `include_seconds` option for `time_field`
 
         <%= form.time_field :foo, include_seconds: false %>
diff --git a/actionview/lib/action_view/helpers/cache_helper.rb b/actionview/lib/action_view/helpers/cache_helper.rb
@@ -4,6 +4,8 @@ module ActionView
   # = Action View Cache Helper
   module Helpers # :nodoc:
     module CacheHelper
+      class UncacheableFragmentError < StandardError; end
+
       # This helper exposes a method for caching fragments of a view
       # rather than an entire action or page. This technique is useful
       # caching pieces like menus, lists of new topics, static HTML
@@ -165,15 +167,45 @@ module CacheHelper
       # expire the cache.
       def cache(name = {}, options = {}, &block)
         if controller.respond_to?(:perform_caching) && controller.perform_caching
-          name_options = options.slice(:skip_digest)
-          safe_concat(fragment_for(cache_fragment_name(name, **name_options), options, &block))
+          CachingRegistry.track_caching do
+            name_options = options.slice(:skip_digest)
+            safe_concat(fragment_for(cache_fragment_name(name, **name_options), options, &block))
+          end
         else
           yield
         end
 
         nil
       end
 
+      # Returns whether the current view fragment is within a +cache+ block.
+      #
+      # Useful when certain fragments aren't cacheable:
+      #
+      #   <% cache project do %>
+      #     <% raise StandardError, "Caching private data!" if caching? %>
+      #   <% end %>
+      def caching?
+        CachingRegistry.caching?
+      end
+
+      # Raises +UncacheableFragmentError+ when called from within a +cache+ block.
+      #
+      # Useful to denote helper methods that can't participate in fragment caching:
+      #
+      #   def project_name_with_time(project)
+      #     uncacheable!
+      #     "#{project.name} - #{Time.now}"
+      #   end
+      #
+      #   # Which will then raise if used within a +cache+ block:
+      #   <% cache project do %>
+      #     <%= project_name_with_time(project) %>
+      #   <% end %>
+      def uncacheable!
+        raise UncacheableFragmentError, "can't be fragment cached" if caching?
+      end
+
       # Cache fragments of a view if +condition+ is true
       #
       #   <% cache_if admin?, project do %>
@@ -259,6 +291,22 @@ def write_fragment_for(name, options)
         end
         controller.write_fragment(name, fragment, options)
       end
+
+      class CachingRegistry
+        extend ActiveSupport::PerThreadRegistry
+
+        attr_accessor :caching
+        alias caching? caching
+
+        def self.track_caching
+          caching_was = self.caching
+          self.caching = true
+
+          yield
+        ensure
+          self.caching = caching_was
+        end
+      end
     end
   end
 end
diff --git a/actionview/test/fixtures/test/caching_predicate.html.erb b/actionview/test/fixtures/test/caching_predicate.html.erb
@@ -0,0 +1,3 @@
+<%= cache "foo" do %>
+  <%= "Cached!" if caching? %>
+<% end %>
diff --git a/actionview/test/fixtures/test/caching_predicate_outside_cache.html.erb b/actionview/test/fixtures/test/caching_predicate_outside_cache.html.erb
@@ -0,0 +1 @@
+<%= "Not cached!" unless caching? %>
diff --git a/actionview/test/fixtures/test/uncacheable.html.erb b/actionview/test/fixtures/test/uncacheable.html.erb
@@ -0,0 +1,3 @@
+<%= cache "uhoh" do %>
+  <%= uncacheable! %>
+<% end %>
diff --git a/actionview/test/template/render_test.rb b/actionview/test/template/render_test.rb
@@ -721,6 +721,24 @@ def test_cache_fragments_inside_render_layout_call_with_block
 
     assert_not_equal cat, dog
   end
+
+  def test_caching_predicate_method
+    result = @view.render(template: "test/caching_predicate")
+
+    assert_match "Cached!", result
+  end
+
+  def test_caching_predicate_method_outside_of_cache
+    result = @view.render(template: "test/caching_predicate_outside_cache")
+
+    assert_match "Not cached!", result
+  end
+
+  def test_uncacheable
+    e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/uncacheable") }
+
+    assert_match "can't be fragment cached", e.cause.message
+  end
 end
 
 class LazyViewRenderTest < ActiveSupport::TestCase
diff --git a/activerecord/CHANGELOG.md b/activerecord/CHANGELOG.md
@@ -6,6 +6,32 @@
 
     *Kevin Newton*
 
+*   Add `ActiveRecord::QueryMethods#in_order_of`.
+
+    This allows you to specify an explicit order that you'd like records
+    returned in based on a SQL expression. By default, this will be accomplished
+    using a case statement, as in:
+
+    ```ruby
+    Post.in_order_of(:id, [3, 5, 1])
+    ```
+
+    will generate the SQL:
+
+    ```sql
+    SELECT "posts".* FROM "posts" ORDER BY CASE "posts"."id" WHEN 3 THEN 1 WHEN 5 THEN 2 WHEN 1 THEN 3 ELSE 4 END ASC
+    ```
+
+    However, because this functionality is built into MySQL in the form of the
+    `FIELD` function, that connection adapter will generate the following SQL
+    instead:
+
+    ```sql
+    SELECT "posts".* FROM "posts" ORDER BY FIELD("posts"."id", 1, 5, 3) DESC
+    ```
+
+    *Kevin Newton*
+
 *   Fix `eager_loading?` when ordering with `Symbol`
 
     `eager_loading?` is triggered correctly when using `order` with symbols.
@@ -42,7 +68,7 @@
 
     *Luis Vasconcellos*, *Eileen M. Uchitelle*
 
-*   Fix `eager_loading?` when ordering with `Hash` syntax.
+*   Fix `eager_loading?` when ordering with `Hash` syntax
 
     `eager_loading?` is triggered correctly when using `order` with hash syntax
     on an outer table.
diff --git a/activerecord/lib/active_record/associations/builder/has_many.rb b/activerecord/lib/active_record/associations/builder/has_many.rb
@@ -7,7 +7,7 @@ def self.macro
     end
 
     def self.valid_options(options)
-      valid = super + [:counter_cache, :join_table, :index_errors, :ensuring_owner_was]
+      valid = super + [:counter_cache, :join_table, :index_errors]
       valid += [:as, :foreign_type] if options[:as]
       valid += [:through, :source, :source_type] if options[:through]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -632,6 +632,15 @@ def database_version # :nodoc:
       def check_version # :nodoc:
       end
 
+      def field_ordered_value(column, values)
+        node = Arel::Nodes::Case.new(column)
+        values.each.with_index(1) do |value, order|
+          node.when(value).then(order)
+        end
+
+        Arel::Nodes::Ascending.new(node.else(values.length + 1))
+      end
+
       class << self
         private
           def initialize_type_map(m)
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -137,6 +137,11 @@ def supports_insert_on_duplicate_update?
         true
       end
 
+      def field_ordered_value(column, values)
+        field = Arel::Nodes::NamedFunction.new("FIELD", [column, values.reverse])
+        Arel::Nodes::Descending.new(field)
+      end
+
       def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
         query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})") == 1
       end
diff --git a/activerecord/lib/active_record/fixture_set/table_row.rb b/activerecord/lib/active_record/fixture_set/table_row.rb
@@ -39,6 +39,29 @@ def timestamp_column_names
         end
       end
 
+      class PrimaryKeyError < StandardError # :nodoc:
+        def initialize(label, association, value)
+          super(<<~MSG)
+            Unable to set #{association.name} to #{value} because the association has a
+            custom primary key (#{association.join_primary_key}) that does not match the
+            associated table's primary key (#{association.klass.primary_key}).
+
+            To fix this, change your fixture from
+
+            #{label}:
+              #{association.name}: #{value}
+
+            to
+
+            #{label}:
+              #{association.foreign_key}: **value**
+
+            where **value** is the #{association.join_primary_key} value for the
+            associated #{association.klass.name} record.
+          MSG
+        end
+      end
+
       def initialize(fixture, table_rows:, label:, now:)
         @table_rows = table_rows
         @label = label
@@ -119,9 +142,13 @@ def resolve_sti_reflections
               fk_name = association.join_foreign_key
 
               if association.name.to_s != fk_name && value = @row.delete(association.name.to_s)
-                if association.polymorphic? && value.sub!(/\s*\(([^)]*)\)\s*$/, "")
-                  # support polymorphic belongs_to as "label (Type)"
-                  @row[association.join_foreign_type] = $1
+                if association.polymorphic?
+                  if value.sub!(/\s*\(([^)]*)\)\s*$/, "")
+                    # support polymorphic belongs_to as "label (Type)"
+                    @row[association.join_foreign_type] = $1
+                  end
+                elsif association.join_primary_key != association.klass.primary_key
+                  raise PrimaryKeyError.new(@label, association, value)
                 end
 
                 fk_type = reflection_class.type_for_attribute(fk_name).type
diff --git a/activerecord/lib/active_record/querying.rb b/activerecord/lib/active_record/querying.rb
@@ -12,7 +12,7 @@ module Querying
       :create_or_find_by, :create_or_find_by!,
       :destroy_all, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
       :find_each, :find_in_batches, :in_batches,
-      :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      :select, :reselect, :order, :in_order_of, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
       :where, :rewhere, :invert_where, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly,
       :and, :or, :annotate, :optimizer_hints, :extending,
       :having, :create_with, :distinct, :references, :none, :unscope, :merge, :except, :only,
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
@@ -387,6 +387,23 @@ def order!(*args) # :nodoc:
       self
     end
 
+    # Allows to specify an order by a specific set of values. Depending on your
+    # adapter this will either use a CASE statement or a built-in function.
+    #
+    #   User.in_order_of(:id, [1, 5, 3])
+    #   # SELECT "users".* FROM "users" ORDER BY FIELD("users"."id", 1, 5, 3)
+    #
+    def in_order_of(column, values)
+      klass.disallow_raw_sql!([column], permit: connection.column_name_with_order_matcher)
+
+      references = column_references([column])
+      self.references_values |= references unless references.empty?
+
+      column = order_column(column.to_s) if column.is_a?(Symbol)
+
+      spawn.order!(connection.field_ordered_value(column, values))
+    end
+
     # Replaces any existing order defined on the relation with the specified order.
     #
     #   User.order('email DESC').reorder('id ASC') # generated SQL has 'ORDER BY id ASC'
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -3087,6 +3087,24 @@ def test_has_many_association_with_same_foreign_key_name
     end
   end
 
+  def test_key_ensuring_owner_was_is_not_valid_without_dependent_option
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        has_many :books, ensuring_owner_was: :destroyed?
+      end
+    end
+
+    assert_match(/Unknown key: :ensuring_owner_was/, error.message)
+  end
+
+  def test_key_ensuring_owner_was_is_valid_when_dependent_option_is_destroy_async
+    Class.new(ActiveRecord::Base) do
+      self.destroy_association_async_job = Class.new
+
+      has_many :books, dependent: :destroy_async, ensuring_owner_was: :destroyed?
+    end
+  end
+
   private
     def force_signal37_to_load_all_clients_of_firm
       companies(:first_firm).clients_of_firm.load_target
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
@@ -6,6 +6,7 @@
 require "models/admin/account"
 require "models/admin/randomly_named_c1"
 require "models/admin/user"
+require "models/author"
 require "models/binary"
 require "models/book"
 require "models/bulb"
@@ -18,6 +19,7 @@
 require "models/developer"
 require "models/dog"
 require "models/doubloon"
+require "models/essay"
 require "models/joke"
 require "models/matey"
 require "models/other_dog"
@@ -1492,6 +1494,16 @@ def self.file_fixture_path
   end
 end
 
+class PrimaryKeyErrorTest < ActiveRecord::TestCase
+  test "generates the correct value" do
+    e = assert_raise(ActiveRecord::FixtureSet::TableRow::PrimaryKeyError) do
+      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/primary_key_error", "primary_key_error")
+    end
+
+    assert_includes e.message, "Unable to set"
+  end
+end
+
 if current_adapter?(:SQLite3Adapter) && !in_memory_db?
   class MultipleFixtureConnectionsTest < ActiveRecord::TestCase
     include ActiveRecord::TestFixtures
diff --git a/activerecord/test/cases/relation/field_ordered_values_test.rb b/activerecord/test/cases/relation/field_ordered_values_test.rb
diff --git a/activerecord/test/fixtures/primary_key_error/primary_key_error.yml b/activerecord/test/fixtures/primary_key_error/primary_key_error.yml
diff --git a/activesupport/activesupport.gemspec b/activesupport/activesupport.gemspec

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+<%= cache "foo" do %>`
	`2`	`+ <%= "Cached!" if caching? %>`
	`3`	`+<% end %>`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+<%= cache "uhoh" do %>`
	`2`	`+ <%= uncacheable! %>`
	`3`	`+<% end %>`