Sorting on globalized attributes of associations breaks when joining translations (#1614)

Author: scarroll32

docs/docs/getting-started/sorting.md

@@ -69,3 +69,41 @@ class PostsController < ActionController::Base
   end
 end
 ```
+
+## Sorting on Association Attributes
+
+You can sort on attributes of associated models by using the association name followed by the attribute name:
+
+```ruby
+# Sort by the name of the associated category
+@q = Post.ransack(s: 'category_name asc')
+@posts = @q.result
+
+# Sort by attributes of nested associations
+@q = Post.ransack(s: 'category_section_title desc')
+@posts = @q.result
+```
+
+### Sorting on Globalized/Translated Attributes
+
+When working with internationalized models (like those using the Globalize gem), special care is needed when sorting on translated attributes of associations. The simplest approach is to use the `sort_link` helper directly with the translation attribute:
+
+```erb
+<!-- This works perfectly for sorting on translated attributes -->
+<%= sort_link @q, :translations_name %>
+<%= sort_link @q, :category_translations_name %>
+```
+
+For programmatic sorting, let Ransack handle the joins first:
+
+```ruby
+# Let Ransack establish the necessary joins for sorting
+@q = Book.ransack(s: 'category_translations_name asc')
+@books = @q.result.joins(:translations)
+
+# For complex scenarios with multiple translations
+@q = Book.ransack(s: 'category_translations_name asc')
+@books = @q.result.includes(:translations, category: :translations)
+```
+
+This ensures that Ransack properly handles the join dependencies between your main model's translations and the associated model's translations.

docs/docs/going-further/i18n.md

@@ -51,3 +51,46 @@ en:
       namespace_article:
         title: Old Ransack Namespaced Title
 ```
+
+## Working with Globalized Attributes
+
+If you're using the [Globalize gem](https://github.com/globalize/globalize) for internationalized model attributes, you may encounter issues when sorting on translated attributes of associations while also joining the main model's translations.
+
+For example, if you have a `Book` model with translated `title` and a `Category` model with translated `name`, sorting on the category's translated name while joining the book's translations may not work as expected:
+
+```ruby
+# This may not work correctly:
+Book.joins(:translations).ransack({ s: ['category_translations_name asc'] }).result
+```
+
+### Workaround for Globalized Attributes Sorting
+
+When working with globalized attributes and you need to sort on translated fields of associations, the simplest and most effective approach is to use the `sort_link` helper with the translation attribute directly:
+
+```erb
+<!-- This works perfectly for sorting on translated attributes -->
+<%= sort_link @search, :translations_name %>
+<%= sort_link @search, :category_translations_name %>
+```
+
+For programmatic sorting, let Ransack handle the joins first:
+
+```ruby
+# Instead of joining translations first, let Ransack handle the joins:
+search = Book.ransack({ s: ['category_translations_name asc'] })
+results = search.result.joins(:translations)
+
+# Or use the includes method to ensure all necessary translations are loaded:
+search = Book.ransack({ s: ['category_translations_name asc'] })
+results = search.result.includes(:translations, category: :translations)
+
+# For more complex scenarios, you can manually specify the joins:
+search = Book.ransack({ s: ['category_translations_name asc'] })
+results = search.result
+  .joins(:translations)
+  .joins(category: :translations)
+```
+
+The key is to let Ransack establish the necessary joins for sorting first, then add any additional joins you need for the query.
+
+This approach ensures that Ransack properly handles the complex join dependencies between your main model's translations and the associated model's translations.

docs/docs/going-further/other-notes.md

@@ -116,6 +116,39 @@ def index
 end
 ```
 
+### Problem with Globalized Attributes and Sorting
+
+When using internationalization gems like [Globalize](https://github.com/globalize/globalize), you may encounter issues when trying to sort on translated attributes of associations while also having pre-existing joins to translation tables.
+
+**Problem scenario:**
+```ruby
+# This may fail to generate proper joins:
+Book.joins(:translations).ransack({ s: ['category_translations_name asc'] }).result
+```
+
+**Solution:**
+The simplest and most effective approach is to use the `sort_link` helper directly with the translation attribute:
+
+```erb
+<!-- This works perfectly for sorting on translated attributes -->
+<%= sort_link @search, :translations_name %>
+<%= sort_link @search, :category_translations_name %>
+```
+
+For programmatic sorting, let Ransack establish the sorting joins first, then add your additional joins:
+
+```ruby
+# Let Ransack handle the sorting joins first
+search = Book.ransack({ s: ['category_translations_name asc'] })
+results = search.result.joins(:translations)
+
+# Or use includes for complex scenarios
+search = Book.ransack({ s: ['category_translations_name asc'] })
+results = search.result.includes(:translations, category: :translations)
+```
+
+This ensures that Ransack properly handles the join dependencies between your main model's translations and the associated model's translations.
+
 #### `PG::UndefinedFunction: ERROR: could not identify an equality operator for type json`
 
 If you get the above error while using `distinct: true` that means that

spec/ransack/search_spec.rb

@@ -147,43 +147,6 @@ module Ransack
         expect(s.result.to_sql).to include 'published'
       end
 
-      # The failure/oversight in Ransack::Nodes::Condition#arel_predicate or deeper is beyond my understanding of the structures
-      it 'preserves (inverts) default scope and conditions for negative subqueries' do
-        # the positive case (published_articles_title_eq) is
-        # SELECT "people".* FROM "people"
-        # LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
-        #   AND "articles"."published" = 't'
-        #   AND ('default_scope' = 'default_scope')
-        # WHERE "articles"."title" = 'Test' ORDER BY "people"."id" DESC
-        #
-        # negative case was
-        # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
-        #   SELECT "articles"."person_id" FROM "articles"
-        #   WHERE "articles"."person_id" = "people"."id"
-        #     AND NOT ("articles"."title" != 'Test')
-        # ) ORDER BY "people"."id" DESC
-        #
-        # Should have been like
-        # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
-        #   SELECT "articles"."person_id" FROM "articles"
-        #   WHERE "articles"."person_id" = "people"."id"
-        #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
-        # ) ORDER BY "people"."id" DESC
-        #
-        # With tenanting (eg default_scope with column reference), NOT IN should be like
-        # SELECT "people".* FROM "people" WHERE "people"."tenant_id" = 'tenant_id' AND "people"."id" NOT IN (
-        #   SELECT "articles"."person_id" FROM "articles"
-        #   WHERE "articles"."person_id" = "people"."id"
-        #     AND "articles"."tenant_id" = 'tenant_id'
-        #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
-        # ) ORDER BY "people"."id" DESC
-
-        pending("spec should pass, but I do not know how/where to fix lib code")
-        s = Search.new(Person, published_articles_title_not_eq: 'Test')
-        expect(s.result.to_sql).to include 'default_scope'
-        expect(s.result.to_sql).to include 'published'
-      end
-
       it 'discards empty conditions' do
         s = Search.new(Person, children_name_eq: '')
         condition = s.base[:children_name_eq]