Merge pull request #14 from lfittl/postgres-0.17

Update crate for rust-postgres 0.17 & Rust 2018 syntax

Author: sfackler

.travis.yml

@@ -2,9 +2,9 @@ language: rust
 rust:
 - nightly
 - beta
-- 1.26.0
+- 1.40.0
 addons:
 postgresql: 9.4
 script:
 - cargo test
-- cargo test --features "with-time with-chrono"
+- cargo test --features "with-chrono-0_4"

Cargo.toml

@@ -2,20 +2,19 @@
 name = "postgres_range"
 version = "0.9.1"
 authors = ["Steven Fackler <[email protected]>"]
+edition = "2018"
 license = "MIT"
 description = "Range support for rust-postgres"
 repository = "https://github.com/sfackler/rust-postgres-range"
 documentation = "https://sfackler.github.io/rust-postgres-range/doc/v0.9.0/postgres_range"
 
 [features]
-with-time = ["time", "postgres-shared/with-time"]
-with-chrono = ["chrono", "postgres-shared/with-chrono"]
+with-chrono-0_4 = ["chrono-04", "postgres-types/with-chrono-0_4"]
 
 [dependencies]
-time ={version = "0.1", optional = true }
-postgres-protocol = "0.3"
-chrono ={version = "0.4.0", optional = true }
-postgres-shared = "0.4.0"
+postgres-protocol = "0.5"
+postgres-types = "0.1"
+chrono-04 ={version = "0.4", package = "chrono", optional = true }
 
 [dev-dependencies]
-postgres ={version = "0.15", features = ["with-time"] }
+postgres ={version = "0.17" }

src/chrono_04.rs

@@ -0,0 +1,23 @@
+use chrono_04::{DateTime,NaiveDateTime,TimeZone};
+
+usecrate::{Normalizable,RangeBound,BoundSided};
+
+impl<T>NormalizableforDateTime<T>
+whereT:TimeZone{
+fnnormalize<S>(bound:RangeBound<S,DateTime<T>>) -> RangeBound<S,DateTime<T>>
+where
+S:BoundSided,
+{
+ bound
+}
+}
+
+implNormalizableforNaiveDateTime
+{
+fnnormalize<S>(bound:RangeBound<S,NaiveDateTime>) -> RangeBound<S,NaiveDateTime>
+where
+S:BoundSided,
+{
+ bound
+}
+}

src/impls.rs

@@ -1,16 +1,17 @@
 use std::error::Error;
-use postgres_shared::types::{FromSql,IsNull,Kind,ToSql,Type};
+use postgres_types::{FromSql,IsNull,Kind,ToSql,Type};
+use postgres_types::private::BytesMut;
 use postgres_protocol::{selfas protocol, types};
 
-use{BoundSided,BoundType,Normalizable,Range,RangeBound};
+usecrate::{BoundSided,BoundType,Normalizable,Range,RangeBound};
 
-impl<T>FromSqlforRange<T>
+impl<'a,T>FromSql<'a>forRange<T>
 where
-T:PartialOrd + Normalizable + FromSql,
+T:PartialOrd + Normalizable + FromSql<'a>,
 {
-fnfrom_sql(ty:&Type,raw:&[u8]) -> Result<Range<T>,Box<Error + Sync + Send>>{
-let element_type = match ty.kind(){
-&Kind::Range(ref ty) => ty,
+fnfrom_sql(ty:&Type,raw:&'a[u8]) -> Result<Range<T>,Box<dynError + Sync + Send>>{
+let element_type = match*ty.kind(){
+Kind::Range(ref ty) => ty,
  _ => panic!("unexpected type{:?}", ty),
 };
 
@@ -25,16 +26,16 @@ where
 }
 
 fnaccepts(ty:&Type) -> bool{
-match ty.kind(){
-&Kind::Range(ref inner) => <TasFromSql>::accepts(inner),
+match*ty.kind(){
+Kind::Range(ref inner) => <TasFromSql>::accepts(inner),
  _ => false,
 }
 }
 }
 
-fnbound_from_sql<T,S>(bound: types::RangeBound<Option<&[u8]>>,ty:&Type) -> Result<Option<RangeBound<S,T>>,Box<Error + Sync + Send>>
+fnbound_from_sql<'a,T,S>(bound: types::RangeBound<Option<&'a[u8]>>,ty:&Type) -> Result<Option<RangeBound<S,T>>,Box<dynError + Sync + Send>>
 where
-T:PartialOrd + Normalizable + FromSql,
+T:PartialOrd + Normalizable + FromSql<'a>,
 S:BoundSided,
 {
 match bound {
@@ -60,9 +61,9 @@ impl<T> ToSql for Range<T>
 where
 T:PartialOrd + Normalizable + ToSql,
 {
-fnto_sql(&self,ty:&Type,buf:&mutVec<u8>) -> Result<IsNull,Box<Error + Sync + Send>>{
-let element_type = match ty.kind(){
-&Kind::Range(ref ty) => ty,
+fnto_sql(&self,ty:&Type,buf:&mutBytesMut) -> Result<IsNull,Box<dynError + Sync + Send>>{
+let element_type = match*ty.kind(){
+Kind::Range(ref ty) => ty,
  _ => panic!("unexpected type{:?}", ty),
 };
 
@@ -80,16 +81,16 @@ where
 }
 
 fnaccepts(ty:&Type) -> bool{
-match ty.kind(){
-&Kind::Range(ref inner) => <TasToSql>::accepts(inner),
+match*ty.kind(){
+Kind::Range(ref inner) => <TasToSql>::accepts(inner),
  _ => false,
 }
 }
 
 to_sql_checked!();
 }
 
-fnbound_to_sql<S,T>(bound:Option<&RangeBound<S,T>>,ty:&Type,buf:&mutVec<u8>) -> Result<types::RangeBound<protocol::IsNull>,Box<Error + Sync + Send>>
+fnbound_to_sql<S,T>(bound:Option<&RangeBound<S,T>>,ty:&Type,buf:&mutBytesMut) -> Result<types::RangeBound<protocol::IsNull>,Box<dynError + Sync + Send>>
 where
 S:BoundSided,
 T:ToSql,
@@ -114,10 +115,10 @@ where
 mod test {
 use std::fmt;
 
-use postgres::{Connection,TlsMode};
+use postgres::{Client,NoTls};
 use postgres::types::{FromSql,ToSql};
-#[cfg(feature = "with-time")]
-usetime::{self,Timespec};
+#[cfg(feature = "with-chrono-0_4")]
+usechrono_04::{TimeZone,Utc,Duration};
 
 macro_rules! test_range {
 ($name:expr, $t:ty, $low:expr, $low_str:expr, $high:expr, $high_str:expr) => ({
@@ -140,16 +141,21 @@ mod test{
 })
 }
 
-fntest_type<T:PartialEq + FromSql + ToSql,S: fmt::Display>(sql_type:&str,checks:&[(T,S)]){
-let conn = Connection::connect("postgres://postgres@localhost",TlsMode::None).unwrap();
+
+fntest_type<T,S>(sql_type:&str,checks:&[(T,S)])
+wherefor<'a>
+T:Sync + PartialEq + FromSql<'a> + ToSql,
+S: fmt::Display
+{
+letmut conn = Client::connect("postgres://postgres@localhost",NoTls).unwrap();
 for&(ref val,ref repr)in checks {
 let stmt = conn.prepare(&*format!("SELECT{}::{}",*repr, sql_type))
 .unwrap();
-let result = stmt.query(&[]).unwrap().iter().next().unwrap().get(0);
+let result = conn.query(&stmt,&[]).unwrap().iter().next().unwrap().get(0);
 assert!(val == &result);
 
 let stmt = conn.prepare(&*format!("SELECT $1::{}", sql_type)).unwrap();
-let result = stmt.query(&[val]).unwrap().iter().next().unwrap().get(0);
+let result = conn.query(&stmt,&[val]).unwrap().iter().next().unwrap().get(0);
 assert!(val == &result);
 }
 }
@@ -164,25 +170,19 @@ mod test{
 test_range!("INT8RANGE",i64,100i64,"100",200i64,"200")
 }
 
-#[cfg(feature = "with-time")]
-fntest_timespec_range_params(sql_type:&str){
-fnt(time:&str) -> Timespec{
- time::strptime(time,"%Y-%m-%d").unwrap().to_timespec()
-}
-let low = "1970-01-01";
-let high = "1980-01-01";
-test_range!(sql_type,Timespec, t(low), low, t(high), high);
-}
-
 #[test]
-#[cfg(feature = "with-time")]
+#[cfg(feature = "with-chrono-0_4")]
 fntest_tsrange_params(){
-test_timespec_range_params("TSRANGE");
+let low = Utc.timestamp(0,0);
+let high = low + Duration::days(10);
+test_range!("TSRANGE",NaiveDateTime, low.naive_utc(),"1970-01-01", high.naive_utc(),"1970-01-11");
 }
 
 #[test]
-#[cfg(feature = "with-time")]
+#[cfg(feature = "with-chrono-0_4")]
 fntest_tstzrange_params(){
-test_timespec_range_params("TSTZRANGE");
+let low = Utc.timestamp(0,0);
+let high = low + Duration::days(10);
+test_range!("TSTZRANGE",DateTime<Utc>, low,"1970-01-01", high,"1970-01-11");
 }
 }

src/lib.rs

@@ -1,27 +1,18 @@
 //! Types dealing with ranges of values
 #![doc(html_root_url = "https://sfackler.github.io/rust-postgres-range/doc/v0.9")]
+#![warn(clippy::all, rust_2018_idioms, missing_docs)]
 
-externcrate postgres_protocol;
 #[macro_use(to_sql_checked)]
-externcratepostgres_shared;
+externcratepostgres_types;
 
-#[cfg(feature = "with-time")]
-externcrate time;
-#[cfg(feature = "with-chrono")]
-externcrate chrono;
+#[cfg(feature = "with-chrono-0_4")]
+mod chrono_04;
 
-#[cfg(test)]
-externcrate postgres;
-
-#[cfg(feature = "with-chrono")]
-use chrono::{DateTime,NaiveDateTime,TimeZone};
 use std::cmp::Ordering;
 use std::fmt;
 use std::i32;
 use std::i64;
 use std::marker::PhantomData;
-#[cfg(feature = "with-time")]
-use time::Timespec;
 
 useBoundSide::{Lower,Upper};
 useBoundType::{Exclusive,Inclusive};
@@ -155,38 +146,6 @@ macro_rules! bounded_normalizable{
 bounded_normalizable!(i32);
 bounded_normalizable!(i64);
 
-#[cfg(feature = "with-time")]
-implNormalizableforTimespec{
-fnnormalize<S>(bound:RangeBound<S,Timespec>) -> RangeBound<S,Timespec>
-where
-S:BoundSided,
-{
- bound
-}
-}
-
-#[cfg(feature = "with-chrono")]
-impl<T>NormalizableforDateTime<T>
-whereT:TimeZone{
-fnnormalize<S>(bound:RangeBound<S,DateTime<T>>) -> RangeBound<S,DateTime<T>>
-where
-S:BoundSided,
-{
- bound
-}
-}
-
-#[cfg(feature = "with-chrono")]
-implNormalizableforNaiveDateTime
-{
-fnnormalize<S>(bound:RangeBound<S,NaiveDateTime>) -> RangeBound<S,NaiveDateTime>
-where
-S:BoundSided,
-{
- bound
-}
-}
-
 /// The possible sides of a bound.
 #[derive(Debug,PartialEq,Eq,Clone,Copy)]
 pubenumBoundSide{
@@ -260,7 +219,7 @@ where
 fnclone(&self) -> RangeBound<S,T>{
 RangeBound{
 value:self.value.clone(),
-type_:self.type_.clone(),
+type_:self.type_,
 _m:PhantomData,
 }
 }
@@ -271,7 +230,7 @@ where
 S:BoundSided,
 T: fmt::Debug,
 {
-fnfmt(&self,fmt:&mut fmt::Formatter) -> fmt::Result{
+fnfmt(&self,fmt:&mut fmt::Formatter<'_>) -> fmt::Result{
  fmt.debug_struct("RangeBound")
 .field("value",&self.value)
 .field("type_",&self.type_)
@@ -284,7 +243,7 @@ where
 S:BoundSided,
 T: fmt::Display,
 {
-fnfmt(&self,fmt:&mut fmt::Formatter) -> fmt::Result{
+fnfmt(&self,fmt:&mut fmt::Formatter<'_>) -> fmt::Result{
 let(lower, upper) = matchself.type_{
 Inclusive => ('[',']'),
 Exclusive => ('(',')'),
@@ -306,9 +265,9 @@ where
 self.value == other.value && self.type_ == other.type_
 }
 
-fnne(&self,other:&RangeBound<S,T>) -> bool{
+/*fn ne(&self, other: &RangeBound<S, T>) -> bool{
  self.value != other.value || self.type_ != other.type_
-}
+ }*/
 }
 
 impl<S,T>EqforRangeBound<S,T>
@@ -364,8 +323,8 @@ where
 /// Constructs a new range bound
 pubfnnew(value:T,type_:BoundType) -> RangeBound<S,T>{
 RangeBound{
-value: value,
-type_: type_,
+ value,
+ type_,
 _m:PhantomData,
 }
 }
@@ -381,7 +340,7 @@ where
 }
 }
 
-structOptBound<'a,S:'a + BoundSided,T:'a>(Option<&'aRangeBound<S,T>>);
+structOptBound<'a,S:BoundSided,T>(Option<&'aRangeBound<S,T>>);
 
 impl<'a,S,T>PartialEqforOptBound<'a,S,T>
 where
@@ -393,10 +352,10 @@ where
  self_ == other
 }
 
-fnne(&self,&OptBound(ref other):&OptBound<'a,S,T>) -> bool{
+/*fn ne(&self, &OptBound(ref other): &OptBound<'a, S, T>) -> bool{
  let &OptBound(ref self_) = self;
  self_ != other
-}
+ }*/
 }
 
 impl<'a,S,T>PartialOrdforOptBound<'a,S,T>
@@ -433,7 +392,7 @@ impl<T> fmt::Display for Range<T>
 where
 T: fmt::Display,
 {
-fnfmt(&self,fmt:&mut fmt::Formatter) -> fmt::Result{
+fnfmt(&self,fmt:&mut fmt::Formatter<'_>) -> fmt::Result{
 matchself.inner{
 Empty => write!(fmt,"empty"),
 Normal(ref lower,ref upper) => {
@@ -558,7 +517,7 @@ where
 let(_,OptBound(lower)) = order(OptBound(self.lower()),OptBound(other.lower()));
 let(OptBound(upper), _) = order(OptBound(self.upper()),OptBound(other.upper()));
 
-Range::new(lower.map(|v| v.clone()), upper.map(|v| v.clone()))
+Range::new(lower.cloned(), upper.cloned())
 }
 
 /// Returns the union of this range with another if it is contiguous.
@@ -595,8 +554,8 @@ where
 None
 }else{
 Some(Range::new(
- l_lower.map(|v| v.clone()),
- u_upper.map(|v| v.clone()),
+ l_lower.cloned(),
+ u_upper.cloned(),
 ))
 }
 }
@@ -758,7 +717,7 @@ mod test{
 assert_eq!(r1,(range!('(',;')')).intersect(&r1));
 
 let r2 = range!('('10i32,;')');
-let exp = Range::new(r2.lower().map(|v| v.clone()), r1.upper().map(|v| v.clone()));
+let exp = Range::new(r2.lower().copied(), r1.upper().copied());
 assert_eq!(exp, r1.intersect(&r2));
 assert_eq!(exp, r2.intersect(&r1));