BulkOperation builder implementations (#56)

- BulkOperation builder implementations

This commit introduces a collection of builders to help with the bulk API. The bulk
API accepts a collection of operations in newline delimited JSON format, where
each operation is represented as a header, followed by an optional source for the
operation. The builders provide functions to build each of the supported operations,
exposing the metadata options available for the operation. Operations can be converted
to a common Operation type which implements the Body trait.

- Add BulkOperations

  helps in building a collection of operations that vary over
types used to represent source documents.

- Add source filtering to update operation, and introduce
SourceFilter enum to handle the variants.

  Add From<T> implementations for SourceFilter to
ease usage.
 
Closes #43

Author: russcam

elasticsearch/src/http/request.rs

@@ -95,7 +95,12 @@ where
     fn write(&self, bytes: &mut BytesMut) -> Result<(), Error> {
         for line in &self.0 {
             line.write(bytes)?;
-            bytes.put_u8(b'\n');
+            // only write a newline if the T impl does not
+            if let Some(b) = bytes.last() {
+                if b != &(b'\n') {
+                    bytes.put_u8(b'\n');
+                }
+            }
         }
         Ok(())
     }
@@ -111,6 +116,16 @@ impl Body for Bytes {
     }
 }
 
+impl Body for BytesMut {
+    fn bytes(&self) -> Option<Bytes> {
+        Some(self.clone().freeze())
+    }
+
+    fn write(&self, bytes: &mut BytesMut) -> Result<(), Error> {
+        self.as_ref().write(bytes)
+    }
+}
+
 impl Body for Vec<u8> {
     fn write(&self, bytes: &mut BytesMut) -> Result<(), Error> {
         self.as_slice().write(bytes)

elasticsearch/src/lib.rs

@@ -331,9 +331,10 @@ pub mod xpack;
 mod client;
 mod error;
 mod generated;
+mod root;
 
 // exposes types within modules at the library root level
-pub use crate::{client::*, error::*, generated::root::*, http::transport::DEFAULT_ADDRESS};
+pub use crate::{client::*, error::*, http::transport::DEFAULT_ADDRESS, root::*};
 
 #[cfg(test)]
 pub mod tests {

elasticsearch/src/params/mod.rs

@@ -18,3 +18,75 @@ pub enum TrackTotalHits {
     /// Accurately track the number of hits up to the specified value
     Count(i64),
 }
+
+/// Control how the `_source` field is returned with every hit.
+///
+/// By default operations return the contents of the `_source` field
+/// unless you have used the `stored_fields` parameter or if the `_source` field is disabled.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum SourceFilter {
+    /// Whether `_source` retrieval should be enabled (`true`) or disabled (`false`)
+    Enable(bool),
+
+    /// A wildcard pattern to control what parts of `_source` should be returned
+    Include(String),
+
+    /// A collection of wildcard patterns to control what parts of `_source` should be returned
+    Includes(Vec<String>),
+
+    /// A collection of wildcard patterns to control what parts of `_source` should
+    /// and should not be returned
+    IncludesExcludes {
+        includes: Vec<String>,
+        excludes: Vec<String>,
+    },
+}
+
+impl From<bool> for SourceFilter {
+    fn from(b: bool) -> Self {
+        SourceFilter::Enable(b)
+    }
+}
+
+impl From<String> for SourceFilter {
+    fn from(include: String) -> Self {
+        SourceFilter::Include(include)
+    }
+}
+
+impl<'a> From<&'a str> for SourceFilter {
+    fn from(include: &'a str) -> Self {
+        SourceFilter::Include(include.to_owned())
+    }
+}
+
+impl From<Vec<String>> for SourceFilter {
+    fn from(includes: Vec<String>) -> Self {
+        SourceFilter::Includes(includes)
+    }
+}
+
+impl<'a> From<Vec<&'a str>> for SourceFilter {
+    fn from(includes: Vec<&'a str>) -> Self {
+        SourceFilter::Includes(includes.iter().map(|s| (*s).to_string()).collect())
+    }
+}
+
+impl From<(Vec<String>, Vec<String>)> for SourceFilter {
+    fn from(includes_excludes: (Vec<String>, Vec<String>)) -> Self {
+        SourceFilter::IncludesExcludes {
+            includes: includes_excludes.0,
+            excludes: includes_excludes.1,
+        }
+    }
+}
+
+impl<'a> From<(Vec<&'a str>, Vec<&'a str>)> for SourceFilter {
+    fn from(includes_excludes: (Vec<&'a str>, Vec<&'a str>)) -> Self {
+        SourceFilter::IncludesExcludes {
+            includes: includes_excludes.0.iter().map(|s| (*s).to_string()).collect(),
+            excludes: includes_excludes.1.iter().map(|s| (*s).to_string()).collect(),
+        }
+    }
+}