Change CreateEmbed::field{,s} to not take builders

Change the `field` and `fields` methods on `builder::CreateEmbed` to not
accept a `CreateEmbedField` builder.

The embed field builder realistically only had (and most likely, only
will) have one optional argument, so the parameters may as well be on
`CreateEmbed::field`.

5 files changed, 57 insertions, 111 deletions

diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index 5475d4c..733a091 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -117,50 +117,35 @@ impl CreateEmbed {
     /// name and 1024 in a field value and a field is inline by default.
     ///
     /// [`CreateEmbedField`]: struct.CreateEmbedField.html
-    pub fn field<F>(mut self, f: F) -> Self
-        where F: FnOnce(CreateEmbedField) -> CreateEmbedField {
-        let map = utils::hashmap_to_json_map(f(CreateEmbedField::default()).0);
-
+    pub fn field<T, U>(mut self, name: T, value: U, inline: bool) -> Self
+        where T: Into<String>, U: Into<String> {
         {
-            let entry = self.0.remove("fields").unwrap_or_else(|| Value::Array(vec![]));
-            let mut arr = match entry {
-                Value::Array(inner) => inner,
-                _ => {
-                    // The type of `entry` should always be a `Value::Array`.
-                    //
-                    // Theoretically this never happens, but you never know.
-                    //
-                    // In the event that it does, just return the current value.
-                    return CreateEmbed(self.0);
-                },
-            };
-            arr.push(Value::Object(map));
-
-            self.0.insert("fields", Value::Array(arr));
+            let entry = self.0
+                .entry("fields")
+                .or_insert_with(|| Value::Array(vec![]));
+
+            if let Value::Array(ref mut inner) = *entry {
+                inner.push(json!({
+                    "inline": inline,
+                    "name": name.into(),
+                    "value": value.into(),
+                }));
+            }
         }
 
-        CreateEmbed(self.0)
+        self
     }
 
     /// Adds multiple fields at once.
-    pub fn fields<It: IntoIterator<Item=CreateEmbedField>>(mut self, fields: It) -> Self {
-        let fields = fields
-            .into_iter()
-            .map(|m| Value::Object(utils::hashmap_to_json_map(m.0)))
-            .collect::<Vec<Value>>();
-
-        {
-            let entry = self.0.remove("fields").unwrap_or_else(|| Value::Array(vec![]));
-            let mut arr = match entry {
-                Value::Array(inner) => inner,
-                _ => return CreateEmbed(self.0),
-            };
-            arr.extend(fields);
-
-            self.0.insert("fields", Value::Array(arr));
+    pub fn fields<T, U, It>(mut self, fields: It) -> Self
+        where It: IntoIterator<Item=(T, U, bool)>,
+              T: Into<String>,
+              U: Into<String> {
+        for field in fields {
+            self = self.field(field.0.into(), field.1.into(), field.2);
         }
 
-        CreateEmbed(self.0)
+        self
     }
 
     /// Set the footer of the embed.
@@ -352,9 +337,7 @@ impl From<Embed> for CreateEmbed {
         }
 
         for field in embed.fields {
-            b = b.field(move |f| {
-                f.inline(field.inline).name(&field.name).value(&field.value)
-            });
+            b = b.field(field.name, field.value, field.inline);
         }
 
         if let Some(image) = embed.image {
@@ -415,51 +398,6 @@ impl CreateEmbedAuthor {
     }
 }
 
-/// A builder to create a fake [`Embed`] object's field, for use with the
-/// [`CreateEmbed::field`] method.
-///
-/// This does not require any field be set. `inline` is set to `true` by
-/// default.
-///
-/// [`Embed`]: ../model/struct.Embed.html
-/// [`CreateEmbed::field`]: struct.CreateEmbed.html#method.field
-#[derive(Clone, Debug)]
-pub struct CreateEmbedField(pub HashMap<&'static str, Value>);
-
-impl CreateEmbedField {
-    /// Set whether the field is inlined. Set to true by default.
-    pub fn inline(mut self, inline: bool) -> Self {
-        self.0.insert("inline", Value::Bool(inline));
-
-        self
-    }
-
-    /// Set the field's name. It can't be longer than 256 characters.
-    pub fn name<D: Display>(mut self, name: D) -> Self {
-        self.0.insert("name", Value::String(format!("{}", name)));
-
-        self
-    }
-
-    /// Set the field's value. It can't be longer than 1024 characters.
-    pub fn value<D: Display>(mut self, value: D) -> Self {
-        self.0.insert("value", Value::String(format!("{}", value)));
-
-        self
-    }
-}
-
-impl Default for CreateEmbedField {
-    /// Creates a builder with default values, setting the value of `inline` to
-    /// `true`.
-    fn default() -> CreateEmbedField {
-        let mut map = HashMap::new();
-        map.insert("inline", Value::Bool(true));
-
-        CreateEmbedField(map)
-    }
-}
-
 /// A builder to create a fake [`Embed`] object's footer, for use with the
 /// [`CreateEmbed::footer`] method.
 ///
diff --git a/src/builder/execute_webhook.rs b/src/builder/execute_webhook.rs
index 9e27a58..6276da1 100644
--- a/src/builder/execute_webhook.rs
+++ b/src/builder/execute_webhook.rs
@@ -35,14 +35,8 @@ use std::default::Default;
 ///     .title("Rust Resources")
 ///     .description("A few resources to help with learning Rust")
 ///     .colour(0xDEA584)
-///     .field(|f| f
-///         .inline(false)
-///         .name("The Rust Book")
-///         .value("A comprehensive resource for all topics related to Rust"))
-///     .field(|f| f
-///         .inline(false)
-///         .name("Rust by Example")
-///         .value("A collection of Rust examples on topics, useable in-browser")));
+///     .field("The Rust Book", "A comprehensive resource for Rust.", false)
+///     .field("Rust by Example", "A collection of Rust examples", false));
 ///
 /// let _ = webhook.execute(false, |w| w
 ///     .content("Here's some information on Rust:")
diff --git a/src/builder/mod.rs b/src/builder/mod.rs
index 496d7e1..3c59c0d 100644
--- a/src/builder/mod.rs
+++ b/src/builder/mod.rs
@@ -16,7 +16,7 @@ mod edit_role;
 mod execute_webhook;
 mod get_messages;
 
-pub use self::create_embed::{CreateEmbed, CreateEmbedAuthor, CreateEmbedField, CreateEmbedFooter};
+pub use self::create_embed::{CreateEmbed, CreateEmbedAuthor, CreateEmbedFooter};
 pub use self::create_invite::CreateInvite;
 pub use self::create_message::CreateMessage;
 pub use self::edit_channel::EditChannel;
diff --git a/src/framework/standard/help_commands.rs b/src/framework/standard/help_commands.rs
index ce90e74..ce3e406 100644
--- a/src/framework/standard/help_commands.rs
+++ b/src/framework/standard/help_commands.rs
@@ -51,7 +51,7 @@ fn remove_aliases(cmds: &HashMap<String, CommandOrAlias>) -> HashMap<&String, &I
     result
 }
 
-/// Checks whether a user is member of required roles 
+/// Checks whether a user is member of required roles
 /// and given the required permissions.
 pub fn has_all_requirements(cmd: &Command, msg: &Message) -> bool {
     if let Some(guild) = msg.guild() {
@@ -116,7 +116,7 @@ pub fn with_embeds(_: &mut Context,
                             }
                             else {
                                 break;
-                            }                 
+                            }
                         },
                         CommandOrAlias::Alias(ref name) => {
                             let actual_command = group.commands.get(name).unwrap();
@@ -157,26 +157,25 @@ pub fn with_embeds(_: &mut Context,
                         }
 
                         if let Some(ref usage) = command.usage {
-                            embed = embed.field(|f| {
-                                f.name("Usage")
-                                    .value(&format!("`{} {}`", command_name, usage))
-                            });
+                            let value = format!("`{} {}`", command_name, usage);
+
+                            embed = embed.field("Usage", value, true);
                         }
 
                         if let Some(ref example) = command.example {
-                            embed = embed.field(|f| {
-                                f.name("Sample usage")
-                                    .value(&format!("`{} {}`", command_name, example))
-                            });
+                            let value = format!("`{} {}`", command_name, example);
+
+                            embed = embed.field("Sample usage", value, true);
                         }
 
                         if group_name != "Ungrouped" {
-                            embed = embed.field(|f| f.name("Group").value(&group_name));
+                            embed = embed.field("Group", group_name, true);
                         }
 
                         if !command.aliases.is_empty() {
                             let aliases = command.aliases.join(", ");
-                            embed = embed.field(|f| f.name("Aliases").value(&aliases));
+
+                            embed = embed.field("Aliases", aliases, true);
                         }
 
                         let available = if command.dm_only {
@@ -187,7 +186,7 @@ pub fn with_embeds(_: &mut Context,
                             "In DM and guilds"
                         };
 
-                        embed = embed.field(|f| f.name("Available").value(available));
+                        embed = embed.field("Available", available, true);
 
                         embed
                     })
@@ -240,7 +239,7 @@ pub fn with_embeds(_: &mut Context,
                 }
 
                 if has_commands {
-                    e = e.field(|f| f.name(group_name).value(&desc));
+                    e = e.field(&group_name[..], &desc[..], true);
                 }
             }
             e
diff --git a/src/model/channel/embed.rs b/src/model/channel/embed.rs
index 74c503d..401f10d 100644
--- a/src/model/channel/embed.rs
+++ b/src/model/channel/embed.rs
@@ -83,10 +83,7 @@ impl Embed {
     /// let embed = Embed::fake(|e| e
     ///     .title("Embed title")
     ///     .description("Making a basic embed")
-    ///     .field(|f| f
-    ///         .name("A field")
-    ///         .value("Has some content.")
-    ///         .inline(false)));
+    ///     .field("A field", "Has some content.", false));
     /// ```
     #[inline]
     pub fn fake<F>(f: F) -> Value
@@ -127,6 +124,24 @@ pub struct EmbedField {
     pub value: String,
 }
 
+impl EmbedField {
+    /// Creates a new embed field.
+    ///
+    /// **Note**: Refer to the [`name`] and [`value`] documentation for maximum
+    /// lengths.
+    ///
+    /// [`name`]: #structfield.name
+    /// [`value`]: #structfield.value
+    pub fn new<T, U>(name: T, value: U, inline: bool) -> Self
+        where T: Into<String>, U: Into<String> {
+        Self {
+            name: name.into(),
+            value: value.into(),
+            inline,
+        }
+    }
+}
+
 /// Footer information for an embed.
 #[derive(Clone, Debug, Deserialize)]
 pub struct EmbedFooter {