Allow tuples to be used with grouped_by

The current implementation of associations basically ignores multiple
level nesting. It lets us get `Vec<(User, Vec<Post>)>`, but not
`Vec<(User, Vec<(Post, Vec<Comment>)>)>`. This allows a tuple of
arbitrary size to be used with `grouped_by`, as long as the first
element in the tuple is the actual child used in the association. This
means that `Vec<(Post, Vec<Comment>)>` implements `GroupedBy<User>`.
I've also moved the impl off of `Vec` and onto `T: IntoIterator`, to get
rid of some unneccesary `collect` calls in tests.

Author: sgrif

diesel/src/associations/belongs_to.rs

@@ -16,7 +16,8 @@ pub trait GroupedBy<Parent>: IntoIterator + Sized {
     fn grouped_by(self, parents: &[Parent]) -> Vec<Vec<Self::Item>>;
 }
 
-impl<Parent, Child> GroupedBy<Parent> for Vec<Child> where
+impl<Parent, Child, Iter> GroupedBy<Parent> for Iter where
+    Iter: IntoIterator<Item=Child>,
     Child: BelongsTo<Parent>,
     Parent: Identifiable,
 {

diesel/src/types/impls/tuples.rs

@@ -1,3 +1,4 @@
+use associations::{BelongsTo, Identifiable};
 use backend::{Backend, SupportsDefaultKeyword};
 use expression::{Expression, SelectableExpression, NonAggregate};
 use persistable::{ColumnInsertValue, InsertValues};
@@ -278,6 +279,21 @@ macro_rules! tuple_impls {
                     Ok(())
                 }
             }
+
+            impl<$($T,)+ Parent> BelongsTo<Parent> for ($($T,)+) where
+                A: BelongsTo<Parent>,
+                Parent: Identifiable,
+            {
+                type ForeignKeyColumn = A::ForeignKeyColumn;
+
+                fn foreign_key(&self) -> Parent::Id {
+                    self.0.foreign_key()
+                }
+
+                fn foreign_key_column() -> Self::ForeignKeyColumn {
+                    A::foreign_key_column()
+                }
+            }
         )+
     }
 }

diesel_tests/tests/associations.rs

@@ -61,6 +61,32 @@ fn grouping_associations_maintains_ordering() {
     assert_eq!(expected_data, users_and_posts);
 }
 
+fn associations_can_be_grouped_multiple_levels_deep() {
+    // I'm manually defining the data rather than loding from the database here,
+    // as it makes the tests *way* more readable if I omit setup here. This is
+    // the equivalent to.
+    //
+    // ```rust
+    // let users = users.load::<User>().unwrap();
+    // let posts = Post::belonging_to(&users).load::<Post>().unwrap();
+    // let comments = Comment::belonging_to(&users).load::<Comment>().unwrap();
+    // ```
+    let users = vec![User::new(1, "Sean"), User::new(2, "Tess")];
+    let posts = vec![Post::new(1, 1, "Hello", None), Post::new(2, 2, "World", None), Post::new(3, 1, "Hello 2", None)];
+    let comments = vec![Comment::new(1, 3, "LOL"), Comment::new(2, 1, "UR dumb"), Comment::new(3, 3, "Funny")]; // Never read the comments
+
+    let expected_data = vec![
+        (users[0].clone(), vec![(posts[0].clone(), vec![comments[1].clone()]), (posts[2].clone(), vec![comments[0].clone(), comments[2].clone()])]),
+        (users[1].clone(), vec![(posts[1].clone(), vec![])]),
+    ];
+
+    let comments = comments.grouped_by(&posts);
+    let posts_and_comments = posts.into_iter().zip(comments).grouped_by(&users);
+    let data = users.into_iter().zip(posts_and_comments).collect::<Vec<_>>();
+
+    assert_eq!(expected_data, data);
+}
+
 fn conn_with_test_data() -> (TestConnection, User, User, User) {
     let connection = connection_with_sean_and_tess_in_users_table();
     insert(&NewUser::new("Jim", None)).into(users::table).execute(&connection).unwrap();

diesel_tests/tests/schema.rs

@@ -31,12 +31,23 @@ impl User {
 }
 
 #[derive(PartialEq, Eq, Debug, Clone, Queryable, Identifiable)]
+#[belongs_to(Post)]
 pub struct Comment {
     id: i32,
     post_id: i32,
     text: String,
 }
 
+impl Comment {
+    pub fn new(id: i32, post_id: i32, text: &str) -> Self {
+        Comment {
+            id: id,
+            post_id: post_id,
+            text: text.into(),
+        }
+    }
+}
+
 #[cfg(feature = "postgres")]
 #[path="postgres_specific_schema.rs"]
 mod backend_specifics;