From c16530bda0e40a93e3f61298ce3eea7adecc4862 Mon Sep 17 00:00:00 2001
From: Tom Hughes <tom@compton.nu>
Date: Wed, 20 Aug 2025 18:38:50 +0100
Subject: [PATCH] Use a common association name for node/way/relation models

---
 app/controllers/api/maps_controller.rb      | 10 +++++-----
 app/controllers/api/relations_controller.rb |  6 +++---
 app/controllers/api/ways_controller.rb      |  2 +-
 app/controllers/nodes_controller.rb         |  2 +-
 app/controllers/old_nodes_controller.rb     |  2 +-
 app/controllers/old_relations_controller.rb |  2 +-
 app/controllers/old_ways_controller.rb      |  6 +++---
 app/controllers/relations_controller.rb     |  2 +-
 app/controllers/ways_controller.rb          |  2 +-
 app/models/node.rb                          |  4 ++--
 app/models/relation.rb                      |  6 +++---
 app/models/way.rb                           |  4 ++--
 test/models/node_test.rb                    |  4 ++--
 test/models/relation_test.rb                |  4 ++--
 test/models/way_test.rb                     |  4 ++--
 test/test_helper.rb                         |  6 +++---
 16 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/app/controllers/api/maps_controller.rb b/app/controllers/api/maps_controller.rb
index c9efd2ee6..6dfd13034 100644
--- a/app/controllers/api/maps_controller.rb
+++ b/app/controllers/api/maps_controller.rb
@@ -28,7 +28,7 @@ module Api
         return
       end
 
-      nodes = Node.bbox(@bounds).where(:visible => true).includes(:node_tags, :changeset).limit(Settings.max_number_of_nodes + 1)
+      nodes = Node.bbox(@bounds).where(:visible => true).includes(:element_tags, :changeset).limit(Settings.max_number_of_nodes + 1)
 
       node_ids = nodes.collect(&:id)
       if node_ids.length > Settings.max_number_of_nodes
@@ -44,7 +44,7 @@ module Api
       else
         way_nodes = WayNode.where(:node_id => node_ids)
         way_ids = way_nodes.collect { |way_node| way_node.id[0] }
-        ways = Way.preload(:way_nodes, :way_tags, :changeset).find(way_ids)
+        ways = Way.preload(:way_nodes, :element_tags, :changeset).find(way_ids)
 
         list_of_way_nodes = ways.flat_map { |way| way.way_nodes.map(&:node_id) }
       end
@@ -52,7 +52,7 @@ module Api
       # - [0] in case some thing links to node 0 which doesn't exist. Shouldn't actually ever happen but it does. FIXME: file a ticket for this
       nodes_to_fetch = (list_of_way_nodes.uniq - node_ids) - [0]
 
-      nodes += Node.includes(:node_tags, :changeset).find(nodes_to_fetch) unless nodes_to_fetch.empty?
+      nodes += Node.includes(:element_tags, :changeset).find(nodes_to_fetch) unless nodes_to_fetch.empty?
 
       @nodes = nodes.filter(&:visible?)
 
@@ -60,10 +60,10 @@ module Api
 
       @relations = Relation.nodes(@nodes)
                            .visible
-                           .includes(:changeset, :relation_members, :relation_tags) +
+                           .includes(:changeset, :relation_members, :element_tags) +
                    Relation.ways(@ways)
                            .visible
-                           .includes(:changeset, :relation_members, :relation_tags)
+                           .includes(:changeset, :relation_members, :element_tags)
 
       # we do not normally return the "other" partners referenced by an relation,
       # e.g. if we return a way A that is referenced by relation X, and there's
diff --git a/app/controllers/api/relations_controller.rb b/app/controllers/api/relations_controller.rb
index 3181a5df1..146ac84c0 100644
--- a/app/controllers/api/relations_controller.rb
+++ b/app/controllers/api/relations_controller.rb
@@ -49,8 +49,8 @@ module Api
 
           # next load the relations and the ways.
 
-          relations = Relation.where(:id => relation_ids).includes(:relation_tags)
-          ways = Way.where(:id => way_ids).includes(:way_nodes, :way_tags)
+          relations = Relation.where(:id => relation_ids).includes(:element_tags)
+          ways = Way.where(:id => way_ids).includes(:way_nodes, :element_tags)
 
           # now additionally collect nodes referenced by ways. Note how we
           # recursively evaluate ways but NOT relations.
@@ -59,7 +59,7 @@ module Api
             way.way_nodes.collect(&:node_id)
           end
           node_ids += way_node_ids.flatten
-          nodes = Node.where(:id => node_ids.uniq).includes(:node_tags)
+          nodes = Node.where(:id => node_ids.uniq).includes(:element_tags)
 
           @nodes = []
           nodes.each do |node|
diff --git a/app/controllers/api/ways_controller.rb b/app/controllers/api/ways_controller.rb
index 2fd86b997..08ad32e47 100644
--- a/app/controllers/api/ways_controller.rb
+++ b/app/controllers/api/ways_controller.rb
@@ -27,7 +27,7 @@ module Api
 
     def show
       @way = Way
-      @way = @way.includes(:nodes => :node_tags) if params[:full]
+      @way = @way.includes(:nodes => :element_tags) if params[:full]
       @way = @way.find(params[:id])
 
       response.last_modified = @way.timestamp unless params[:full]
diff --git a/app/controllers/nodes_controller.rb b/app/controllers/nodes_controller.rb
index 0ef07dbbf..f5fbb200d 100644
--- a/app/controllers/nodes_controller.rb
+++ b/app/controllers/nodes_controller.rb
@@ -1,7 +1,7 @@
 class NodesController < ElementsController
   def show
     @type = "node"
-    @feature = Node.preload(:node_tags, :containing_relation_members, :changeset => [:changeset_tags, :user], :ways => :way_tags).find(params[:id])
+    @feature = Node.preload(:element_tags, :containing_relation_members, :changeset => [:changeset_tags, :user], :ways => :element_tags).find(params[:id])
   rescue ActiveRecord::RecordNotFound
     render "browse/not_found", :status => :not_found
   end
diff --git a/app/controllers/old_nodes_controller.rb b/app/controllers/old_nodes_controller.rb
index f3bb40e4b..8db5068ac 100644
--- a/app/controllers/old_nodes_controller.rb
+++ b/app/controllers/old_nodes_controller.rb
@@ -1,7 +1,7 @@
 class OldNodesController < OldElementsController
   def index
     @type = "node"
-    @current_feature = @feature = Node.preload(:node_tags).find(params[:id])
+    @current_feature = @feature = Node.preload(:element_tags).find(params[:id])
     @old_features, @newer_features_version, @older_features_version = get_page_items(
       OldNode.where(:node_id => params[:id]),
       :cursor_column => :version,
diff --git a/app/controllers/old_relations_controller.rb b/app/controllers/old_relations_controller.rb
index f470a1a87..194dc8c42 100644
--- a/app/controllers/old_relations_controller.rb
+++ b/app/controllers/old_relations_controller.rb
@@ -1,7 +1,7 @@
 class OldRelationsController < OldElementsController
   def index
     @type = "relation"
-    @current_feature = @feature = Relation.preload(:relation_tags).find(params[:id])
+    @current_feature = @feature = Relation.preload(:element_tags).find(params[:id])
     @old_features, @newer_features_version, @older_features_version = get_page_items(
       OldRelation.where(:relation_id => params[:id]),
       :cursor_column => :version,
diff --git a/app/controllers/old_ways_controller.rb b/app/controllers/old_ways_controller.rb
index e3078dbbc..817458ff8 100644
--- a/app/controllers/old_ways_controller.rb
+++ b/app/controllers/old_ways_controller.rb
@@ -1,11 +1,11 @@
 class OldWaysController < OldElementsController
   def index
     @type = "way"
-    @current_feature = @feature = Way.preload(:way_tags).find(params[:id])
+    @current_feature = @feature = Way.preload(:element_tags).find(params[:id])
     @old_features, @newer_features_version, @older_features_version = get_page_items(
       OldWay.where(:way_id => params[:id]),
       :cursor_column => :version,
-      :includes => [:old_tags, { :changeset => [:changeset_tags, :user], :old_nodes => { :node => [:node_tags, :ways] } }]
+      :includes => [:old_tags, { :changeset => [:changeset_tags, :user], :old_nodes => { :node => [:element_tags, :ways] } }]
     )
   rescue ActiveRecord::RecordNotFound
     render "browse/not_found", :status => :not_found
@@ -14,7 +14,7 @@ class OldWaysController < OldElementsController
   def show
     @type = "way"
     @current_feature = Way.find(params[:id])
-    @feature = OldWay.preload(:old_tags, :changeset => [:changeset_tags, :user], :old_nodes => { :node => [:node_tags, :ways] }).find([params[:id], params[:version]])
+    @feature = OldWay.preload(:old_tags, :changeset => [:changeset_tags, :user], :old_nodes => { :node => [:element_tags, :ways] }).find([params[:id], params[:version]])
   rescue ActiveRecord::RecordNotFound
     render "browse/not_found", :status => :not_found
   end
diff --git a/app/controllers/relations_controller.rb b/app/controllers/relations_controller.rb
index 5fc8806e8..5541e4a32 100644
--- a/app/controllers/relations_controller.rb
+++ b/app/controllers/relations_controller.rb
@@ -1,7 +1,7 @@
 class RelationsController < ElementsController
   def show
     @type = "relation"
-    @feature = Relation.preload(:relation_tags, :containing_relation_members, :changeset => [:changeset_tags, :user]).find(params[:id])
+    @feature = Relation.preload(:element_tags, :containing_relation_members, :changeset => [:changeset_tags, :user]).find(params[:id])
   rescue ActiveRecord::RecordNotFound
     render "browse/not_found", :status => :not_found
   end
diff --git a/app/controllers/ways_controller.rb b/app/controllers/ways_controller.rb
index d5c5d8736..2e0c9e39b 100644
--- a/app/controllers/ways_controller.rb
+++ b/app/controllers/ways_controller.rb
@@ -1,7 +1,7 @@
 class WaysController < ElementsController
   def show
     @type = "way"
-    @feature = Way.preload(:way_tags, :containing_relation_members, :changeset => [:changeset_tags, :user], :nodes => [:node_tags, { :ways => :way_tags }]).find(params[:id])
+    @feature = Way.preload(:element_tags, :containing_relation_members, :changeset => [:changeset_tags, :user], :nodes => [:element_tags, { :ways => :element_tags }]).find(params[:id])
   rescue ActiveRecord::RecordNotFound
     render "browse/not_found", :status => :not_found
   end
diff --git a/app/models/node.rb b/app/models/node.rb
index e5655ad0a..502898629 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -37,7 +37,7 @@ class Node < ApplicationRecord
   has_many :way_nodes
   has_many :ways, :through => :way_nodes
 
-  has_many :node_tags
+  has_many :element_tags, :class_name => "NodeTag"
 
   has_many :old_way_nodes
   has_many :ways_via_history, :class_name => "Way", :through => :old_way_nodes, :source => :way
@@ -206,7 +206,7 @@ class Node < ApplicationRecord
   end
 
   def tags
-    @tags ||= node_tags.to_h { |t| [t.k, t.v] }
+    @tags ||= element_tags.to_h { |t| [t.k, t.v] }
   end
 
   attr_writer :tags
diff --git a/app/models/relation.rb b/app/models/relation.rb
index 8c844325f..ab89409a3 100644
--- a/app/models/relation.rb
+++ b/app/models/relation.rb
@@ -30,7 +30,7 @@ class Relation < ApplicationRecord
   has_many :old_relations, -> { order(:version) }, :inverse_of => :current_relation
 
   has_many :relation_members, -> { order(:sequence_id) }, :inverse_of => :relation
-  has_many :relation_tags
+  has_many :element_tags, :class_name => "RelationTag"
 
   has_many :containing_relation_members, :class_name => "RelationMember", :as => :member
   has_many :containing_relations, :class_name => "Relation", :through => :containing_relation_members, :source => :relation
@@ -128,7 +128,7 @@ class Relation < ApplicationRecord
   end
 
   def tags
-    @tags ||= relation_tags.to_h { |t| [t.k, t.v] }
+    @tags ||= element_tags.to_h { |t| [t.k, t.v] }
   end
 
   attr_writer :members, :tags
@@ -281,7 +281,7 @@ class Relation < ApplicationRecord
       clone.save!
 
       tags = self.tags.clone
-      relation_tags.each do |old_tag|
+      element_tags.each do |old_tag|
         key = old_tag.k
         # if we can match the tags we currently have to the list
         # of old tags, then we never set the tags_changed flag. but
diff --git a/app/models/way.rb b/app/models/way.rb
index 13cf81983..266f7b6e7 100644
--- a/app/models/way.rb
+++ b/app/models/way.rb
@@ -32,7 +32,7 @@ class Way < ApplicationRecord
   has_many :way_nodes, -> { order(:sequence_id) }, :inverse_of => :way
   has_many :nodes, :through => :way_nodes
 
-  has_many :way_tags
+  has_many :element_tags, :class_name => "WayTag"
 
   has_many :containing_relation_members, :class_name => "RelationMember", :as => :member
   has_many :containing_relations, :class_name => "Relation", :through => :containing_relation_members, :source => :relation
@@ -110,7 +110,7 @@ class Way < ApplicationRecord
   end
 
   def tags
-    @tags ||= way_tags.to_h { |t| [t.k, t.v] }
+    @tags ||= element_tags.to_h { |t| [t.k, t.v] }
   end
 
   attr_writer :nds, :tags
diff --git a/test/models/node_test.rb b/test/models/node_test.rb
index 9efe9a9c9..22d88f142 100644
--- a/test/models/node_test.rb
+++ b/test/models/node_test.rb
@@ -309,10 +309,10 @@ class NodeTest < ActiveSupport::TestCase
     assert_equal "Element node/23 has duplicate tags with key dup", message_update.message
   end
 
-  def test_node_tags
+  def test_element_tags
     node = create(:node)
     taglist = create_list(:node_tag, 2, :node => node)
-    tags = Node.find(node.id).node_tags.order(:k)
+    tags = Node.find(node.id).element_tags.order(:k)
     assert_equal taglist.count, tags.count
     taglist.sort_by!(&:k).each_index do |i|
       assert_equal taglist[i].k, tags[i].k
diff --git a/test/models/relation_test.rb b/test/models/relation_test.rb
index 405dd353d..e0910f4fc 100644
--- a/test/models/relation_test.rb
+++ b/test/models/relation_test.rb
@@ -135,11 +135,11 @@ class RelationTest < ActiveSupport::TestCase
     assert_equal ["Relation", other_relation.id, "some relation"], members[2]
   end
 
-  def test_relation_tags
+  def test_element_tags
     relation = create(:relation)
     taglist = create_list(:relation_tag, 2, :relation => relation)
 
-    tags = Relation.find(relation.id).relation_tags.order(:k)
+    tags = Relation.find(relation.id).element_tags.order(:k)
     assert_equal taglist.count, tags.count
     taglist.sort_by!(&:k).each_index do |i|
       assert_equal taglist[i].k, tags[i].k
diff --git a/test/models/way_test.rb b/test/models/way_test.rb
index 36debfac0..d2ca08750 100644
--- a/test/models/way_test.rb
+++ b/test/models/way_test.rb
@@ -174,10 +174,10 @@ class WayTest < ActiveSupport::TestCase
     assert_equal node3.id, nodes[2]
   end
 
-  def test_way_tags
+  def test_element_tags
     way = create(:way)
     taglist = create_list(:way_tag, 2, :way => way)
-    tags = Way.find(way.id).way_tags.order(:k)
+    tags = Way.find(way.id).element_tags.order(:k)
     assert_equal taglist.count, tags.count
     taglist.sort_by!(&:k).each_index do |i|
       assert_equal taglist[i].k, tags[i].k
diff --git a/test/test_helper.rb b/test/test_helper.rb
index 90a33dbf6..26f05793c 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -229,7 +229,7 @@ module ActiveSupport
         el["lon"] = node.lon.to_s
       end
 
-      add_tags_to_xml_node(el, node.node_tags)
+      add_tags_to_xml_node(el, node.element_tags)
 
       el
     end
@@ -260,7 +260,7 @@ module ActiveSupport
         el << node_el
       end
 
-      add_tags_to_xml_node(el, way.way_tags)
+      add_tags_to_xml_node(el, way.element_tags)
 
       el
     end
@@ -285,7 +285,7 @@ module ActiveSupport
         el << member_el
       end
 
-      add_tags_to_xml_node(el, relation.relation_tags)
+      add_tags_to_xml_node(el, relation.element_tags)
 
       el
     end
-- 
2.39.5