Rename relationships to associations to avoid naming confusion

Author: benedikt

lib/userlist/push/resource.rb

@@ -19,18 +19,18 @@ def from_payload(payload, config = Userlist.config)
           new(payload, config)
         end
 
-        def relationship_names
-          @relationship_names ||= relationships.keys
+        def association_names
+          @association_names ||= associations.keys
         end
 
-        def relationships
-          @relationships ||= {}
+        def associations
+          @associations ||= {}
         end
 
       protected
 
         def has_one(name, type:) # rubocop:disable Naming/PredicateName
-          relationships[name.to_sym] = { type: type }
+          associations[name.to_sym] = { type: type }
 
           generated_methods.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}                                        # def company
@@ -40,13 +40,13 @@ def #{name}                                        # def company
         end
 
         def has_many(name, **options) # rubocop:disable Naming/PredicateName
-          relationships[name.to_sym] = options
+          associations[name.to_sym] = options
 
           generated_methods.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}                                                             # def companies
-              relationship = self.class.relationships[:#{name}]                     #   relationship = self.class.relationships[:companies]
+              associations = self.class.associations[:#{name}]                     #   associations = self.class.associations[:companies]
                                                                                     #
-              ResourceCollection.new(payload[:#{name}], relationship, self, config) #   ResourceCollection.new(payload[:companies], relationship, self, config)
+              ResourceCollection.new(payload[:#{name}], associations, self, config) #   ResourceCollection.new(payload[:companies], associations, self, config)
             end                                                                     # end
           RUBY
         end
@@ -96,11 +96,11 @@ def eql?(other)
       alias == eql?
 
       def attribute_names
-        payload.keys.map(&:to_sym) - relationship_names
+        payload.keys.map(&:to_sym) - association_names
       end
 
-      def relationship_names
-        self.class.relationship_names.to_a
+      def association_names
+        self.class.association_names.to_a
       end
 
       def push?

lib/userlist/push/serializer.rb

@@ -40,31 +40,31 @@ def serialize_resource(resource)
           serialized[name] = resource.send(name)
         end
 
-        resource.relationship_names.each do |name|
-          next unless result = serialize_relationship(resource.send(name))
+        resource.association_names.each do |name|
+          next unless result = serialize_association(resource.send(name))
 
           serialized[name] = result
         end
 
         serialized
       end
 
-      def serialize_relationship(relationship)
-        return unless relationship
+      def serialize_association(association)
+        return unless association
 
-        case relationship
+        case association
         when Userlist::Push::ResourceCollection
-          serialize_collection(relationship)
+          serialize_collection(association)
         when Userlist::Push::Resource
-          serialize_resource(relationship)
+          serialize_resource(association)
         else
-          raise "Cannot serialize relationship type: #{relationship.class}"
+          raise "Cannot serialize association type: #{association.class}"
         end
       end
 
       def serialize_collection(collection)
         serialized = collection
-          .map(&method(:serialize_relationship))
+          .map(&method(:serialize_association))
           .compact
           .reject(&:empty?)