mocking up type mapping

Author: KodrAus

types/src/date/date.rs

@@ -6,7 +6,7 @@ use serde::{ Serialize, Deserialize, Serializer, Deserializer };
 use super::{ DT, DefaultFormat };
 use super::format::{ Format, ParseError };
 use super::mapping::{ ElasticDateMapping, DefaultDateMapping };
-use ::mapping::{ ElasticMapping, ElasticType };
+use ::mapping::{ ElasticMapping, ElasticDataType };
 
 pub use chrono::{ Datelike, Timelike };
 
@@ -172,7 +172,7 @@ impl <F: Format, T: ElasticMapping<F> + ElasticDateMapping<F>> DateTime<F, T> {
 	}
 }
 
-impl <F: Format, T: ElasticMapping<F> + ElasticDateMapping<F>> ElasticType<T, F> for DateTime<F, T> {
+impl <F: Format, T: ElasticMapping<F> + ElasticDateMapping<F>> ElasticDataType<T, F> for DateTime<F, T> {
 
 }
 

types/src/date/format.rs

@@ -4,64 +4,12 @@ use chrono::format::{ Parsed, Item };
 use std::error::Error;
 use std::fmt;
 
-/// Represents an error encountered during parsing.
-#[derive(Debug)]
-pub struct ParseError {
-	kind: ParseErrorKind
-}
-
-#[derive_Debug]
-enum ParseErrorKind {
-    Chrono(chrono::ParseError),
-    Other(String)
-}
-
-impl fmt::Display for ParseError {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		match self.kind {
-			ParseErrorKind::Chrono(ref err) => write!(f, "Chrono error: {}", err),
-			ParseErrorKind::Other(ref err) => write!(f, "Error: {}", err)
-		}
-	}
-}
-
-impl Error for ParseError {
-	fn description(&self) -> &str {
-		match self.kind {
-			ParseErrorKind::Chrono(ref err) => err.description(),
-			ParseErrorKind::Other(ref err) => &err[..]
-		}
-	}
-
-	fn cause(&self) -> Option<&Error> {
-		match self.kind {
-			ParseErrorKind::Chrono(ref err) => Some(err),
-			ParseErrorKind::Other(_) => None
-		}
-	}
-}
-
-impl From<chrono::ParseError> for ParseError {
-	fn from(err: chrono::ParseError) -> ParseError {
-		ParseError {
-			kind: ParseErrorKind::Chrono(err)
-		}
-	}
-}
-
-impl From<String> for ParseError {
-	fn from(err: String) -> ParseError {
-		ParseError {
-			kind: ParseErrorKind::Other(err)
-		}
-	}
-}
-
 /// A format used for parsing and formatting dates.
 /// 
 /// The format is specified as two functions; `parse` and `format`, which are backed by `chrono::format::Item`s.
 /// Not all formats use the `Item`s though, for example `EpochMillis`, which is more efficient than other formats.
-pub trait Format {
+pub trait Format
+where Self : Default {
 	/// Parses a date string to a `chrono::DateTime<UTC>` result.
 	/// 
 	/// The date string must match the format specified by `fmt()`.
@@ -121,3 +69,56 @@ pub trait Format {
 	/// This is the string used when defining the format in the field mapping.
 	fn name() -> &'static str;
 }
+
+/// Represents an error encountered during parsing.
+#[derive(Debug)]
+pub struct ParseError {
+	kind: ParseErrorKind
+}
+
+#[derive_Debug]
+enum ParseErrorKind {
+    Chrono(chrono::ParseError),
+    Other(String)
+}
+
+impl fmt::Display for ParseError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self.kind {
+			ParseErrorKind::Chrono(ref err) => write!(f, "Chrono error: {}", err),
+			ParseErrorKind::Other(ref err) => write!(f, "Error: {}", err)
+		}
+	}
+}
+
+impl Error for ParseError {
+	fn description(&self) -> &str {
+		match self.kind {
+			ParseErrorKind::Chrono(ref err) => err.description(),
+			ParseErrorKind::Other(ref err) => &err[..]
+		}
+	}
+
+	fn cause(&self) -> Option<&Error> {
+		match self.kind {
+			ParseErrorKind::Chrono(ref err) => Some(err),
+			ParseErrorKind::Other(_) => None
+		}
+	}
+}
+
+impl From<chrono::ParseError> for ParseError {
+	fn from(err: chrono::ParseError) -> ParseError {
+		ParseError {
+			kind: ParseErrorKind::Chrono(err)
+		}
+	}
+}
+
+impl From<String> for ParseError {
+	fn from(err: String) -> ParseError {
+		ParseError {
+			kind: ParseErrorKind::Other(err)
+		}
+	}
+}

types/src/date/formats.rs

@@ -8,7 +8,7 @@ use super::{ Format, ParseError };
 /// 
 /// # Links
 /// - [Elasticsearch Doc](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html#built-in-date-formats)
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct BasicDateTimeNoMillis;
 impl Format for BasicDateTimeNoMillis {
 	fn fmt<'a>() -> Vec<Item<'a>> {
@@ -26,7 +26,7 @@ impl Format for BasicDateTimeNoMillis {
 /// 
 /// # Links
 /// - [Elasticsearch Doc](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html#built-in-date-formats)
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct BasicDateTime;
 impl Format for BasicDateTime {
 	fn fmt<'a>() -> Vec<Item<'a>>{
@@ -47,7 +47,7 @@ impl Format for BasicDateTime {
 /// 
 /// # Links
 /// - [Elasticsearch Doc](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html#built-in-date-formats)
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct EpochMillis;
 impl Format for EpochMillis {
 	fn fmt<'a>() -> Vec<Item<'a>>{

types/src/date/mapping.rs

@@ -20,6 +20,7 @@ use ::mapping::{ ElasticMapping, IndexAnalysis };
 /// use elastic_types::date::mapping::ElasticDateMapping;
 /// use elastic_types::date::{ BasicDateTime, Format };
 /// 
+/// #[derive(Default)]
 /// struct MyDateMapping;
 /// impl serde::Serialize for MyDateMapping {
 /// 	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -41,7 +42,7 @@ use ::mapping::{ ElasticMapping, IndexAnalysis };
 /// 
 /// The above example binds the mapping to the `BasicDateTime` format, so `get_null_value` returns a properly formated value.
 pub trait ElasticDateMapping<T: Format>
-where Self : Sized + Serialize {
+where Self : Sized + Serialize + Default {
 	/// Field-level index time boosting. Accepts a floating point number, defaults to `1.0`.
 	fn boost() -> Option<f32> {
 		None
@@ -99,14 +100,13 @@ where Self : Sized + Serialize {
 impl <T: Format, M: ElasticDateMapping<T>> ElasticMapping<T> for M {
 	type Visitor = ElasticDateMappingVisitor<T, M>;
 
-	fn field_type() -> &'static str {
+	fn data_type() -> &'static str {
 		"date"
 	}
 }
 
-//TODO: Make this take in str for field name
 /// Default mapping for `DateTime`.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct DefaultDateMapping<T: Format = DefaultFormat> {
 	phantom: PhantomData<T>
 }
@@ -148,7 +148,7 @@ impl <F: Format, T: ElasticDateMapping<F>> Default for ElasticDateMappingVisitor
 impl <F: Format, T: ElasticDateMapping<F>> serde::ser::MapVisitor for ElasticDateMappingVisitor<F, T> {
 	fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
 	where S: Serializer {
-		try!(serializer.serialize_struct_elt("type", T::field_type()));
+		try!(serializer.serialize_struct_elt("type", T::data_type()));
 
 		if let Some(boost) = T::boost() {
 			try!(serializer.serialize_struct_elt("boost", boost));

types/src/mapping.rs

@@ -5,18 +5,26 @@ pub mod prelude {
     //! 
     //! This is a convenience module to make it easy to build mappings for multiple types without too many `use` statements.
     
-    pub use super::{ ElasticType, ElasticMapping, NullMapping, IndexAnalysis, ElasticMappingVisitor };
+    pub use super::{ ElasticDataType, ElasticMapping, NullMapping, IndexAnalysis, ElasticMappingVisitor };
     pub use ::date::mapping::*;
     pub use ::string::mapping::*;
 }
 
 use std::marker::PhantomData;
 use serde;
 
-/// The base requirements for mapping an Elasticsearch type.
+/// The base representation of an Elasticsearch data type.
 /// 
-/// Each type will have its own implementing structures with extra type-specific mapping parameters.
-pub trait ElasticMapping<F = ()> {
+/// # Links
+/// 
+/// - [Elasticsearch docs](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-types.html)
+pub trait ElasticDataType<T: ElasticMapping<F>, F> { }
+
+/// The base requirements for mapping an Elasticsearch data type.
+/// 
+/// Each type has its own implementing structures with extra type-specific mapping parameters.
+pub trait ElasticMapping<F = ()>
+where Self: Default + serde::Serialize {
 	/// The serialisation visitor used to inspect this mapping.
 	type Visitor : serde::ser::MapVisitor + Default;
 
@@ -31,43 +39,42 @@ pub trait ElasticMapping<F = ()> {
 	}
 
 	/// Get the type name for this mapping, like `date` or `string`.
-	fn field_type() -> &'static str {
+	fn data_type() -> &'static str {
 		""
 	}
 }
 
 /// A mapping implementation for a non-core type, or any where nobody cares about how it's mapped.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Default)]
 pub struct NullMapping;
 impl ElasticMapping for NullMapping {
 	type Visitor = NullMappingVisitor;
+
+	fn data_type() -> &'static str {
+		"object"
+	}
 }
 
 impl serde::Serialize for NullMapping {
-	fn serialize<S>(&self, _: &mut S) -> Result<(), S::Error>
+	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
 	where S: serde::Serializer {
-		Ok(())
+		serializer.serialize_struct("mapping", NullMappingVisitor::default())
 	}
 }
 
 /// A default empty visitor.
 #[derive(Default, Debug, PartialEq)]
 pub struct NullMappingVisitor;
 impl serde::ser::MapVisitor for NullMappingVisitor {
-	fn visit<S>(&mut self, _: &mut S) -> Result<Option<()>, S::Error>
+	fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
 	where S: serde::Serializer {
+		try!(serializer.serialize_struct_elt("type", NullMapping::data_type()));
+
 		Ok(None)
 	}
 }
 
-impl ElasticType<(), NullMapping> for .. { }
-
-/// A type that can be indexed in Elasticsearch.
-//TODO: Rename to ElasticDataType
-pub trait ElasticType<T: ElasticMapping<F>, F> { }
-
-//TODO: Need ElasticType, which is a main type that can be derived
-//This needs to map each property. Probably through a custom derive
+impl ElasticDataType<(), NullMapping> for .. { }
 
 /// Should the field be searchable? Accepts `not_analyzed` (default) and `no`.
 #[derive(Debug, Clone, Copy)]

types/src/string/mapping.rs

@@ -4,7 +4,7 @@ use std::collections::BTreeMap;
 use std::marker::PhantomData;
 use serde;
 use serde::{ Serializer, Serialize };
-use ::mapping::{ ElasticMapping, ElasticType, IndexAnalysis };
+use ::mapping::{ ElasticMapping, ElasticDataType, IndexAnalysis };
 
 /// The base requirements for mapping a `string` type.
 /// 
@@ -20,6 +20,7 @@ use ::mapping::{ ElasticMapping, ElasticType, IndexAnalysis };
 /// use elastic_types::mapping::ElasticMapping;
 /// use elastic_types::string::mapping::{ ElasticStringMapping, ElasticStringFieldMapping };
 /// 
+/// #[derive(Default)]
 /// struct MyStringMapping;
 /// impl serde::Serialize for MyStringMapping {
 /// 	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -50,7 +51,7 @@ use ::mapping::{ ElasticMapping, ElasticType, IndexAnalysis };
 /// # }
 /// ```
 pub trait ElasticStringMapping 
-where Self : Sized + Serialize {
+where Self : Sized + Serialize + Default {
 	/// Field-level index time boosting. Accepts a floating point number, defaults to `1.0`.
 	fn boost() -> Option<f32> {
 		None
@@ -156,7 +157,7 @@ where Self : Sized + Serialize {
 impl <M: ElasticStringMapping> ElasticMapping for M {
 	type Visitor = ElasticStringMappingVisitor<M>;
 
-	fn field_type() -> &'static str {
+	fn data_type() -> &'static str {
 		"string"
 	}
 }
@@ -466,7 +467,7 @@ impl serde::Serialize for TermVector {
 }
 
 /// Default mapping for `String`.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct DefaultStringMapping;
 impl ElasticStringMapping for DefaultStringMapping { }
 
@@ -479,9 +480,8 @@ impl Serialize for DefaultStringMapping {
 }
 
 /// A Rust representation of an Elasticsearch `string`.
-pub trait ElasticStringType<T: ElasticMapping + ElasticStringMapping> where Self: Sized + ElasticType<T, ()> { }
+pub trait ElasticStringType<T: ElasticMapping + ElasticStringMapping> where Self: Sized + ElasticDataType<T, ()> { }
 
-//TODO: Make this take in str for field name
 /// Base visitor for serialising string mappings.
 #[derive(Debug, PartialEq)]
 pub struct ElasticStringMappingVisitor<T: ElasticMapping> {
@@ -500,7 +500,7 @@ impl <T: ElasticMapping + ElasticStringMapping> serde::ser::MapVisitor for Elast
 	#[allow(cyclomatic_complexity)]
 	fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
 	where S: serde::Serializer {
-		try!(serializer.serialize_struct_elt("type", T::field_type()));
+		try!(serializer.serialize_struct_elt("type", T::data_type()));
 
 		if let Some(boost) = T::boost() {
 			try!(serializer.serialize_struct_elt("boost", boost));

types/src/string/string.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 use serde;
 use serde::{ Serialize, Deserialize, Serializer, Deserializer };
 use super::mapping::{ ElasticStringType, ElasticStringMapping, DefaultStringMapping };
-use ::mapping::{ ElasticMapping, ElasticType };
+use ::mapping::{ ElasticMapping, ElasticDataType };
 
 /// An Elasticsearch `string` with a mapping.
 /// 
@@ -58,7 +58,7 @@ impl <T: ElasticMapping + ElasticStringMapping> ElasticString<T> {
 	}
 }
 
-impl <T: ElasticMapping + ElasticStringMapping> ElasticType<T, ()> for ElasticString<T> { }
+impl <T: ElasticMapping + ElasticStringMapping> ElasticDataType<T, ()> for ElasticString<T> { }
 impl <T: ElasticMapping + ElasticStringMapping> ElasticStringType<T> for ElasticString<T> { }
 
 impl From<String> for ElasticString<DefaultStringMapping> {
@@ -119,7 +119,7 @@ impl<'a, T: ElasticMapping + ElasticStringMapping> PartialEq<ElasticString<T>> f
 	}
 }
 
-impl ElasticType<DefaultStringMapping, ()> for String { }
+impl ElasticDataType<DefaultStringMapping, ()> for String { }
 impl ElasticStringType<DefaultStringMapping> for String { }
 
 //Serialize elastic string