Merge branch 'master' of https:/KodrAus/elasticsearch-rs

README.md

@@ -16,6 +16,14 @@ The `elastic_hyper` client is a thin layer over `hyper`; it just maps functions
 For serialisation though, the `elastic_macros` crate provides the `json!` macro for serialising abitrary rust-like code to json. 
 The deserialisation story is a work in progress.
 
+Add `elastic_hyper` and `elastic_macros` to your `Cargo.toml`:
+
+```
+[dependencies]
+elastic_hyper = "*"
+elastic_macros = "*"
+```
+
 Ping the availability of your cluster:
 
 ```rust
@@ -86,11 +94,21 @@ Right now, it's used by `elastic_hyper` to build the client, but could also be u
 
 ### elastic_hyper
 
+[![Latest Version](https://img.shields.io/crates/v/elastic_hyper.svg)](https://crates.io/crates/elastic_hyper)
+
 [Docs](http://kodraus.github.io/rustdoc/elastic_hyper/)
 [Issues](https:/KodrAus/elasticsearch-rs/labels/hyper)
 
 Provides a [hyper](https:/hyperium/hyper) implementation of the Elasticsearch REST API. This is the current client that works purely through JSON. This crate is responsible for the `gen` in `elastic_codegen` and builds its own source and tests.
 
+### elastic_macros
+
+[![Latest Version](https://img.shields.io/crates/v/elastic_macros.svg)](https://crates.io/crates/elastic_macros)
+
+[Docs](http://kodraus.github.io/rustdoc/elastic_macros/)
+
+Provides compiler plugins and macros for the `elastic_types` crate, such as parsing a date format to an array of [Items](https:/lifthrasiir/rust-chrono/blob/master/src/format/mod.rs#L161) at compile-time for efficient runtime date parsing.
+
 ### elastic_types
 
 [Docs](http://kodraus.github.io/rustdoc/elastic_types/)
@@ -99,11 +117,3 @@ Provides a [hyper](https:/hyperium/hyper) implementation of the Elas
 Provides rust implementations of the main [Elasticsearch types](https://www.elastic.co/guide/en/elasticsearch/reference/1.4/mapping-core-types.html) (like `date`) and responses/errors. This crate is not required for working with `elastic_hyper`, but does have a lot of utility, especially for designing your document types.
 
 The `elastic_types` crate tries not to reinvent the wheel wherever possible and relies on some common dependencies for types, such as [chrono](https:/lifthrasiir/rust-chrono) for dates and [rust-geo](https:/georust/rust-geo) for geometry.
-
-### elastic_macros
-
-[![Latest Version](https://img.shields.io/crates/v/elastic_macros.svg)](https://crates.io/crates/elastic_macros)
-
-[Docs](http://kodraus.github.io/rustdoc/elastic_macros/)
-
-Provides compiler plugins and macros for the `elastic_types` crate, such as parsing a date format to an array of [Items](https:/lifthrasiir/rust-chrono/blob/master/src/format/mod.rs#L161) at compile-time for efficient runtime date parsing.

codegen/src/api/ast.rs

@@ -60,8 +60,8 @@ impl HttpVerb {
  /// let verb = HttpVerb::parse("GET");
  /// assert!(verb == HttpVerb::Get);
  /// ```
- pub fn parse(_method: &str) -> HttpVerb {
- match _method {
+ pub fn parse(method: &str) -> HttpVerb {
+ match method {
  "HEAD" => HttpVerb::Head,
  "POST" => HttpVerb::Post,
  "PUT" => HttpVerb::Put,
@@ -438,7 +438,7 @@ impl Param {
  }
 
  /// Get the `Type` for the `Param`.
- pub fn get_type<'a>(&'a self) -> Type<'a> {
+ pub fn get_type(&self) -> Type {
  match self._type {
  Some(ref t) => Type::parse(t, &self.options),
  None => Type::parse("unknown", &self.options)

codegen/src/api/gen/mod.rs

@@ -33,7 +33,7 @@ pub mod parse {
  let (remainder, param) = take_while1(part_start, |c| c != b'}');
 
  if param.len() > 0 {
- parts.push(param.to_string());
+ parts.push(param.to_owned());
  }
 
  parse_path_param_parts(remainder, parts);
@@ -57,7 +57,7 @@ pub mod parse {
  let skip_param = shift_while(remainder, |c| c != b'}');
 
  if part.len() > 0 {
- parts.push(part.to_string());
+ parts.push(part.to_owned());
  }
 
  if skip_param.len() != 0 {
@@ -107,7 +107,7 @@ pub mod parse {
  let (remainder, part) = take_while1(path, |c| c != b'.');
 
  if part.len() > 0 {
- parts.push(part.to_string());
+ parts.push(part.to_owned());
  }
 
  if remainder.len() != 0 {

codegen/src/api/gen/rust.rs

@@ -57,10 +57,7 @@ impl error::Error for ApiGenError {
  }
 
  fn cause(&self) -> Option<&error::Error> {
- match self.kind {
- ApiGenErrorKind::Parse(_) => None,
- ApiGenErrorKind::Other(_) => None
- }
+ None
  }
 }
 
@@ -74,7 +71,7 @@ impl From<String> for ApiGenError {
 
 impl api::Endpoint {
  /// Gets the name of the Endpoint if it's set or returns an empty string.
- pub fn get_name<'a>(&'a self) -> &'a str {
+ pub fn get_name(&self) -> &str {
  match self.name {
  Some(ref n) => n,
  None => ""
@@ -106,21 +103,18 @@ impl api::Endpoint {
  /// - `post_index_type`
  /// 
  /// This is to try and prevent collisions with the names where not a lot of info about each endpoint is available.
- pub fn get_fns<'a>(&'a self) -> Result<Vec<UrlFn<'a>>, ApiGenError> {
+ pub fn get_fns(&self) -> Result<Vec<UrlFn>, ApiGenError> {
  let mut fns = Vec::new();
  for path in &self.url.paths {
  //Parse the params used by this path
  let mut fn_parts = BTreeMap::new();
  let params = try!(parse_path_params(&path));
 
- for param in params.iter() {
+ for param in &params {
  let param = param.to_owned();
- match self.url.parts.get(&param) {
- Some(part) => {
- let _ = fn_parts.insert(param, part);
- },
- None => ()
- };
+ if let Some(part) = self.url.parts.get(&param) {
+ fn_parts.insert(param, part);
+ }
  }
 
  //Return a function for each method on the url
@@ -362,7 +356,7 @@ pub fn url_push_decl<'a, I, K>(url_base: Ident, url_parts: I, param_parts: K) ->
  //Sum the url parts
  let mut url_iter = url_part_ids
  .iter()
- .map(|&ident| ident);
+ .cloned();
 
  let mut add_expr = len_add(
  len_expr(ident_expr(url_base)), 
@@ -375,7 +369,7 @@ pub fn url_push_decl<'a, I, K>(url_base: Ident, url_parts: I, param_parts: K) ->
  //Sum the url params
  let mut param_part_ids = Vec::new();
  for url_param in param_parts {
- param_part_ids.push(url_param.clone());
+ param_part_ids.push(url_param);
  add_expr = len_add(add_expr, len_expr(ident_expr(url_param)));
  }
 
@@ -451,8 +445,8 @@ pub fn url_push_decl<'a, I, K>(url_base: Ident, url_parts: I, param_parts: K) ->
 
  //Thread through each url part and param, pushing a part, then a param to keep the url in order
  let (mut part_iter, mut param_iter) = (
- url_part_ids.iter().map(|&ident| ident),
- param_part_ids.iter().map(|&ident| ident)
+ url_part_ids.iter().cloned(),
+ param_part_ids.iter().cloned()
  );
  let mut cont = true;
  while cont {

codegen/src/api/parse.rs

@@ -113,7 +113,7 @@ pub fn from_reader<R>(rdr: &mut R) -> ParseResult<Endpoint> where R: Read {
  let (name, tree) = try!(
  data.iter()
  .next()
- .ok_or("unexpected format".to_string())
+ .ok_or("unexpected format".to_owned())
  );
 
  //Deserialise the api ast and set the name
@@ -122,7 +122,7 @@ pub fn from_reader<R>(rdr: &mut R) -> ParseResult<Endpoint> where R: Read {
 
  Ok(endpoint)
  },
- _ => Err(ParseError::from("unexpected format".to_string()))
+ _ => Err(ParseError::from("unexpected format".to_owned()))
  }
 }
 

codegen/src/emit/default/mod.rs

@@ -66,16 +66,13 @@ impl <'a, E> Emitter<'a> for CtxtFreeEmitter<E> where E: From<EmitError> {
  type CtxtBrw = ();
  type Error = E;
 
- fn get_cx(&self) {
+ fn get_cx(&self) { }
 
- }
-
- fn emit<Emittable, EmError, W>(&self, e: &'a Emittable, writer: &'a mut W) -> Result<(), Self::Error> where 
- Emittable: Emit<Self::CtxtBrw, EmError>, 
- EmError: Into<EmitError>, 
- W: Write {
- let cx = self.get_cx();
- emit!(cx, e, writer)
+ #[allow(let_unit_value)]
+ fn emit<Emittable, EmError, W>(&self, e: &'a Emittable, writer: &'a mut W) -> Result<(), Self::Error> 
+ where Emittable: Emit<Self::CtxtBrw, EmError>, EmError: Into<EmitError>, W: Write {
+ let cx = self.get_cx();
+ emit!(cx, e, writer)
  }
 
  fn emit_str<W>(&self, e: &str, writer: &mut W) -> Result<(), Self::Error> where W: Write {

codegen/src/emit/default/string.rs

@@ -10,7 +10,7 @@ impl Emit<(), EmitError> for AsRef<String> {
 
 impl <'a> Emit<(), EmitError> for &'a str {
  fn emit(&self, _: ()) -> Result<String, EmitError> {
- Ok(self.to_string())
+ Ok((*self).to_owned())
  }
 }
 

codegen/src/emit/mod.rs

@@ -18,8 +18,8 @@ mod macros {
  );
 
  $writer.write_all(&emitted.into_bytes()[..]).map_err(|e| {
- let _e: EmitError = e.into();
- _e.into()
+ let err: EmitError = e.into();
+ err.into()
  })
  }
  }
@@ -30,8 +30,8 @@ mod macros {
  ($emittable:ident, $writer:ident) => {
  {
  $writer.write_all($emittable.as_bytes()).map_err(|e| {
- let _e: EmitError = e.into();
- _e.into()
+ let err: EmitError = e.into();
+ err.into()
  })
  }
  }
@@ -124,7 +124,7 @@ impl error::Error for EmitError {
  fn description(&self) -> &str {
  match self.kind {
  EmitErrorKind::Io(ref err) => err.description(),
- EmitErrorKind::Other(ref err) => &err[..]
+ EmitErrorKind::Other(ref err) => &err
  }
  }
 

codegen/src/gen/rust/fun.rs

@@ -83,9 +83,8 @@ impl Fn {
  self.stmts.extend(body.stmts.to_vec());
 
  //Set the return type if the function takes one
- match self.decl.output {
- FunctionRetTy::Ty(_) => self.expr = body.expr.to_owned(),
- _ => ()
+ if let FunctionRetTy::Ty(_) = self.decl.output {
+ self.expr = body.expr.to_owned();
  }
 
  self

codegen/src/gen/rust/mod.rs

@@ -12,40 +12,40 @@ pub use self::fun::*;
 pub use self::ty::*;
 
 pub mod parse {
- //! Rust Codegen parsers.
+ //! Rust Codegen parsers.
 
- use ::parse::*;
+ use ::parse::*;
 
- /// Parses a Rust path to its segments.
- /// 
- /// The path is split by '::' and each segment is added in order.
- /// 
- /// # Examples
- /// 
- /// Parse a path:
- /// 
- /// ```
- /// use elastic_codegen::gen::rust::parse::parse_path;
- /// 
- /// let parsed = parse_path("crate::mod_a::mod_b::fn");
- /// ```
- pub fn parse_path(path: &str) -> Vec<String> {
-  let mut parts = Vec::new();
- parse_path_parts(path.as_bytes(), &mut parts);
- 
- parts
- }
+ /// Parses a Rust path to its segments.
+ /// 
+ /// The path is split by '::' and each segment is added in order.
+ /// 
+ /// # Examples
+ /// 
+ /// Parse a path:
+ /// 
+ /// ```
+ /// use elastic_codegen::gen::rust::parse::parse_path;
+ /// 
+ /// let parsed = parse_path("crate::mod_a::mod_b::fn");
+ /// ```
+ pub fn parse_path(path: &str) -> Vec<String> {
+  let mut parts = Vec::new();
+ parse_path_parts(path.as_bytes(), &mut parts);
+ 
+ parts
+ }
 
- fn parse_path_parts(path: &[u8], parts: &mut Vec<String>) {
-  if path.len() == 0 {
-  return;
-  }
- 
- let trim_colons = shift_while(path, |c| c == b':');
- let (remainder, seg) = take_while1(trim_colons, |c| c != b':');
- 
- parts.push(seg.to_string());
- 
- parse_path_parts(remainder, parts);
- }
+ fn parse_path_parts(path: &[u8], parts: &mut Vec<String>) {
+  if path.len() == 0 {
+  return;
+  }
+ 
+ let trim_colons = shift_while(path, |c| c == b':');
+ let (remainder, seg) = take_while1(trim_colons, |c| c != b':');
+ 
+ parts.push(seg.to_owned());
+ 
+ parse_path_parts(remainder, parts);
+ }
 }

codegen/src/gen/rust/ty.rs

@@ -60,26 +60,24 @@ pub fn ty_ptr<T>(mutbl: Mutability, lifetime: Option<Lifetime>, opts: TyPathOpts
 
 /// Get the full-path name of a type.
 pub fn type_of<'a, T>() -> &'a str {
- let t =
- unsafe {
- type_name::<T>()
- };
- t
+ unsafe {
+ type_name::<T>()
+ } 
 }
 
 fn _type_of<T>(opts: TyPathOpts) -> String {
  match opts {
- TyPathOpts::Full => type_of::<T>().to_string(),
+ TyPathOpts::Full => type_of::<T>().to_owned(),
  TyPathOpts::NameOnly => {
  let mut parts = parse_path(type_of::<T>());
- parts.pop().unwrap_or(String::new())
+ parts.pop().unwrap_or_default()
  }
  }
 }
 
 /// Get the full-path name of a type inferred from the argument.
 pub fn infer_type_of<T>(_: &T) -> &str {
- type_of::<T>()
+ type_of::<T>()
 }
 
 /// The kind of path to use in the type Ident.