xeos
/
chrono
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #164 from quodlibetor/enable-clippy 

Enable Clippy for all builds in Travis
This commit is contained in:
Brandon W Maister 2017-07-09 15:48:20 -05:00 committed by GitHub
parent f2f97258aa ce6ea4d8d1
commit 91d5dd46cf
13 changed files with 120 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.travis.sh
View File

@ -46,11 +46,25 @@ build_only() {
channel build -v --features 'serde bincode'
}
run_clippy() {
# cached installation will not work on a later nightly
if [ -n "${TRAVIS}" ] && ! cargo install clippy --debug --force; then
echo "COULD NOT COMPILE CLIPPY, IGNORING CLIPPY TESTS"
exit
fi
cargo clippy --features 'serde bincode rustc-serialize' -- -Dclippy
}
rustc --version
cargo --version
CHANNEL=nightly
build_and_test
if [ "x${CLIPPY}" = xy ] ; then
run_clippy
else
build_and_test
fi
CHANNEL=beta
build_and_test

6
.travis.yml
View File

@ -12,9 +12,15 @@ os:
matrix:
allow_failures:
- rust: nightly
env: CLIPPY=n
include:
- rust: nightly
env: CLIPPY=y
env:
global:
- LD_LIBRARY_PATH: /usr/local/lib
- CLIPPY: n
script: ./.travis.sh
notifications:
email: false

2
src/date.rs
View File

@ -184,7 +184,7 @@ impl<Tz: TimeZone> Date<Tz> {
/// Retrieves an associated offset from UTC.
#[inline]
pub fn offset<'a>(&'a self) -> &'a Tz::Offset {
pub fn offset(&self) -> &Tz::Offset {
&self.offset
}

72
src/datetime.rs
View File

@ -6,8 +6,6 @@
use std::{str, fmt, hash};
use std::cmp::Ordering;
use std::ops::{Add, Sub};
#[cfg(feature = "rustc-serialize")]
use std::ops::Deref;
use std::time::{SystemTime, UNIX_EPOCH};
use oldtime::Duration as OldDuration;
@ -29,30 +27,6 @@ pub struct DateTime<Tz: TimeZone> {
offset: Tz::Offset,
}
/// A DateTime that can be deserialized from a timestamp
///
/// A timestamp here is seconds since the epoch
#[cfg(feature = "rustc-serialize")]
pub struct TsSeconds<Tz: TimeZone>(DateTime<Tz>);
#[cfg(feature = "rustc-serialize")]
impl<Tz: TimeZone> From<TsSeconds<Tz>> for DateTime<Tz> {
/// Pull the inner DateTime<Tz> out
fn from(obj: TsSeconds<Tz>) -> DateTime<Tz> {
obj.0
}
}
#[cfg(feature = "rustc-serialize")]
impl<Tz: TimeZone> Deref for TsSeconds<Tz> {
type Target = DateTime<Tz>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<Tz: TimeZone> DateTime<Tz> {
/// Makes a new `DateTime` with given *UTC* datetime and offset.
/// The local datetime should be constructed via the `TimeZone` trait.
@ -124,7 +98,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
/// Retrieves an associated offset from UTC.
#[inline]
pub fn offset<'a>(&'a self) -> &'a Tz::Offset {
pub fn offset(&self) -> &Tz::Offset {
&self.offset
}
@ -517,9 +491,9 @@ fn test_decodable_json<FUtc, FFixed, FLocal, E>(utc_from_str: FUtc,
fn test_decodable_json_timestamps<FUtc, FFixed, FLocal, E>(utc_from_str: FUtc,
fixed_from_str: FFixed,
local_from_str: FLocal)
where FUtc: Fn(&str) -> Result<TsSeconds<Utc>, E>,
FFixed: Fn(&str) -> Result<TsSeconds<FixedOffset>, E>,
FLocal: Fn(&str) -> Result<TsSeconds<Local>, E>,
where FUtc: Fn(&str) -> Result<rustc_serialize::TsSeconds<Utc>, E>,
FFixed: Fn(&str) -> Result<rustc_serialize::TsSeconds<FixedOffset>, E>,
FLocal: Fn(&str) -> Result<rustc_serialize::TsSeconds<Local>, E>,
E: ::std::fmt::Debug
{
fn norm<Tz: TimeZone>(dt: &Option<DateTime<Tz>>) -> Option<(&DateTime<Tz>, &Tz::Offset)> {
@ -543,9 +517,10 @@ fn test_decodable_json_timestamps<FUtc, FFixed, FLocal, E>(utc_from_str: FUtc,
}
#[cfg(feature = "rustc-serialize")]
mod rustc_serialize {
pub mod rustc_serialize {
use std::fmt;
use super::{DateTime, TsSeconds};
use std::ops::Deref;
use super::DateTime;
use offset::{TimeZone, LocalResult, Utc, Local, FixedOffset};
use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
@ -579,7 +554,7 @@ mod rustc_serialize {
impl Decodable for TsSeconds<FixedOffset> {
fn decode<D: Decoder>(d: &mut D) -> Result<TsSeconds<FixedOffset>, D::Error> {
from(FixedOffset::east(0).timestamp_opt(d.read_i64()?, 0), d)
.map(|dt| TsSeconds(dt))
.map(TsSeconds)
}
}
@ -592,10 +567,31 @@ mod rustc_serialize {
}
}
/// A `DateTime` that can be deserialized from a timestamp
///
/// A timestamp here is seconds since the epoch
#[derive(Debug)]
pub struct TsSeconds<Tz: TimeZone>(DateTime<Tz>);
impl<Tz: TimeZone> From<TsSeconds<Tz>> for DateTime<Tz> {
/// Pull the inner DateTime<Tz> out
fn from(obj: TsSeconds<Tz>) -> DateTime<Tz> {
obj.0
}
}
impl<Tz: TimeZone> Deref for TsSeconds<Tz> {
type Target = DateTime<Tz>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl Decodable for TsSeconds<Utc> {
fn decode<D: Decoder>(d: &mut D) -> Result<TsSeconds<Utc>, D::Error> {
from(Utc.timestamp_opt(d.read_i64()?, 0), d)
.map(|dt| TsSeconds(dt))
.map(TsSeconds)
}
}
@ -685,7 +681,7 @@ pub mod serde {
use {DateTime, Utc, FixedOffset};
use offset::{LocalResult, TimeZone};
/// Deserialize a DateTime from a seconds timestamp
/// Deserialize a `DateTime` from a seconds timestamp
///
/// Intended for use with `serde`s `deserialize_with` attribute.
///
@ -771,19 +767,19 @@ pub mod serde {
fn visit_i64<E>(self, value: i64) -> Result<DateTime<FixedOffset>, E>
where E: de::Error
{
from(FixedOffset::east(0).timestamp_opt(value, 0), value)
from(FixedOffset::east(0).timestamp_opt(value, 0), &value)
}
/// Deserialize a timestamp in seconds since the epoch
fn visit_u64<E>(self, value: u64) -> Result<DateTime<FixedOffset>, E>
where E: de::Error
{
from(FixedOffset::east(0).timestamp_opt(value as i64, 0), value)
from(FixedOffset::east(0).timestamp_opt(value as i64, 0), &value)
}
}
// try!-like function to convert a LocalResult into a serde-ish Result
fn from<T, E, V>(me: LocalResult<T>, ts: V) -> Result<T, E>
fn from<T, E, V>(me: LocalResult<T>, ts: &V) -> Result<T, E>
where E: de::Error,
V: fmt::Display,
T: fmt::Display,

4
src/format/parse.rs
View File

@ -230,9 +230,9 @@ pub fn parse<'a, I>(parsed: &mut Parsed, mut s: &str, items: I) -> ParseResult<(
Item::Numeric(spec, _pad) => {
use super::Numeric::*;
type Setter = fn(&mut Parsed, i64) -> ParseResult<()>;
let (width, signed, set): (usize, bool,
fn(&mut Parsed, i64) -> ParseResult<()>) = match spec {
let (width, signed, set): (usize, bool, Setter) = match spec {
Year => (4, true, Parsed::set_year),
YearDiv100 => (2, false, Parsed::set_year_div_100),
YearMod100 => (2, false, Parsed::set_year_mod_100),

2
src/format/parsed.rs
View File

@ -538,7 +538,7 @@ impl Parsed {
// it's okay, just do not try to overwrite the existing field.
59 => {}
// `datetime` is known to be off by one second.
0 => { datetime = datetime - OldDuration::seconds(1); }
0 => { datetime -= OldDuration::seconds(1); }
// otherwise it is impossible.
_ => return Err(IMPOSSIBLE)
}

31
src/format/scan.rs
View File

@ -36,7 +36,8 @@ pub fn number(s: &str, min: usize, max: usize) -> ParseResult<(&str, i64)> {
if window.len() > max { window = &window[..max]; }
// scan digits
let upto = window.iter().position(|&c| c < b'0' || b'9' < c).unwrap_or(window.len());
let upto = window.iter().position(|&c| c < b'0' || b'9' < c)
.unwrap_or_else(|| window.len());
if upto < min {
return Err(if window.is_empty() {TOO_SHORT} else {INVALID});
}
@ -224,28 +225,24 @@ pub fn timezone_offset_zulu<F>(s: &str, colon: F) -> ParseResult<(&str, i32)>
pub fn timezone_offset_2822(s: &str) -> ParseResult<(&str, Option<i32>)> {
// tries to parse legacy time zone names
let upto = s.as_bytes().iter().position(|&c| match c { b'a'...b'z' | b'A'...b'Z' => false,
_ => true }).unwrap_or(s.len());
_ => true })
.unwrap_or_else(|| s.len());
if upto > 0 {
let name = &s[..upto];
let s = &s[upto..];
let offset_hours = |o| Ok((s, Some(o * 3600)));
if equals(name, "gmt") || equals(name, "ut") {
Ok((s, Some(0)))
} else if equals(name, "est") {
Ok((s, Some(-5 * 3600)))
offset_hours(0)
} else if equals(name, "edt") {
Ok((s, Some(-4 * 3600)))
} else if equals(name, "cst") {
Ok((s, Some(-6 * 3600)))
} else if equals(name, "cdt") {
Ok((s, Some(-5 * 3600)))
} else if equals(name, "mst") {
Ok((s, Some(-7 * 3600)))
} else if equals(name, "mdt") {
Ok((s, Some(-6 * 3600)))
offset_hours(-4)
} else if equals(name, "est") || equals(name, "cdt") {
offset_hours(-5)
} else if equals(name, "cst") || equals(name, "mdt") {
offset_hours(-6)
} else if equals(name, "mst") || equals(name, "pdt") {
offset_hours(-7)
} else if equals(name, "pst") {
Ok((s, Some(-8 * 3600)))
} else if equals(name, "pdt") {
Ok((s, Some(-7 * 3600)))
offset_hours(-8)
} else {
Ok((s, None)) // recommended by RFC 2822: consume but treat it as -0000
}

11
src/format/strftime.rs
View File

@ -149,7 +149,7 @@ Notes:
use super::{Item, Numeric, Fixed, Pad};
/// Parsing iterator for `strftime`-like format strings.
#[derive(Clone)]
#[derive(Clone, Debug)]
pub struct StrftimeItems<'a> {
/// Remaining portion of the string.
remainder: &'a str,
@ -180,7 +180,7 @@ impl<'a> Iterator for StrftimeItems<'a> {
match self.remainder.chars().next() {
// we are done
None => return None,
None => None,
// the next item is a specifier
Some('%') => {
@ -237,7 +237,7 @@ impl<'a> Iterator for StrftimeItems<'a> {
'Y' => num0!(Year),
'Z' => fix!(TimezoneName),
'a' => fix!(ShortWeekdayName),
'b' => fix!(ShortMonthName),
'b' | 'h' => fix!(ShortMonthName),
'c' => recons![fix!(ShortWeekdayName), sp!(" "), fix!(ShortMonthName),
sp!(" "), nums!(Day), sp!(" "), num0!(Hour), lit!(":"),
num0!(Minute), lit!(":"), num0!(Second), sp!(" "), num0!(Year)],
@ -245,7 +245,6 @@ impl<'a> Iterator for StrftimeItems<'a> {
'e' => nums!(Day),
'f' => num0!(Nanosecond),
'g' => num0!(IsoYearMod100),
'h' => fix!(ShortMonthName),
'j' => num0!(Ordinal),
'k' => nums!(Hour),
'l' => nums!(Hour12),
@ -305,7 +304,7 @@ impl<'a> Iterator for StrftimeItems<'a> {
Some(c) if c.is_whitespace() => {
// `%` is not a whitespace, so `c != '%'` is redundant
let nextspec = self.remainder.find(|c: char| !c.is_whitespace())
.unwrap_or(self.remainder.len());
.unwrap_or_else(|| self.remainder.len());
assert!(nextspec > 0);
let item = sp!(&self.remainder[..nextspec]);
self.remainder = &self.remainder[nextspec..];
@ -315,7 +314,7 @@ impl<'a> Iterator for StrftimeItems<'a> {
// the next item is literal
_ => {
let nextspec = self.remainder.find(|c: char| c.is_whitespace() || c == '%')
.unwrap_or(self.remainder.len());
.unwrap_or_else(|| self.remainder.len());
assert!(nextspec > 0);
let item = lit!(&self.remainder[..nextspec]);
self.remainder = &self.remainder[nextspec..];

8
src/lib.rs
View File

@ -359,6 +359,7 @@
#![cfg_attr(bench, feature(test))] // lib stability features as per RFC #507
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
extern crate time as oldtime;
extern crate num;
@ -374,7 +375,7 @@ pub use oldtime::Duration;
#[doc(no_inline)] pub use naive::{NaiveDate, IsoWeek, NaiveTime, NaiveDateTime};
pub use date::{Date, MIN_DATE, MAX_DATE};
pub use datetime::DateTime;
#[cfg(feature = "rustc-serialize")] pub use datetime::TsSeconds;
#[cfg(feature = "rustc-serialize")] pub use datetime::rustc_serialize::TsSeconds;
pub use format::{ParseError, ParseResult};
/// A convenience module appropriate for glob imports (`use chrono::prelude::*;`).
@ -410,7 +411,10 @@ pub mod naive {
pub use self::date::{NaiveDate, MIN_DATE, MAX_DATE};
pub use self::isoweek::IsoWeek;
pub use self::time::NaiveTime;
pub use self::datetime::{NaiveDateTime, TsSeconds};
pub use self::datetime::NaiveDateTime;
#[cfg(feature = "rustc-serialize")]
pub use self::datetime::rustc_serialize::TsSeconds;
/// Serialization/Deserialization of naive types in alternate formats
///

12
src/naive/date.rs
View File

@ -3,7 +3,7 @@
//! ISO 8601 calendar date without timezone.
use std::{str, fmt, hash};
use std::{str, fmt};
use std::ops::{Add, Sub, AddAssign, SubAssign};
use num::traits::ToPrimitive;
use oldtime::Duration as OldDuration;
@ -93,7 +93,7 @@ const MAX_BITS: usize = 44;
/// The year number is same to that of the [calendar date](#calendar-date).
///
/// This is currently the internal format of Chrono's date types.
#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Clone)]
pub struct NaiveDate {
ymdf: DateImpl, // (year << 13) | of
}
@ -1302,14 +1302,6 @@ impl Datelike for NaiveDate {
}
}
/// `NaiveDate` can be used as a key to the hash maps.
impl hash::Hash for NaiveDate {
fn hash<H: hash::Hasher>(&self, state: &mut H) {
// don't need to strip flags, as we can safely assume that it is correct
self.ymdf.hash(state);
}
}
/// An addition of `Duration` to `NaiveDate` discards the fractional days,
/// rounding to the closest integral number of days towards `Duration::zero()`.
///

55
src/naive/datetime.rs
View File

@ -4,7 +4,7 @@
//! ISO 8601 date and time without timezone.
use std::{str, fmt, hash};
use std::ops::{Add, Sub, Deref, AddAssign, SubAssign};
use std::ops::{Add, Sub, AddAssign, SubAssign};
use num::traits::ToPrimitive;
use oldtime::Duration as OldDuration;
@ -53,24 +53,6 @@ pub struct NaiveDateTime {
time: NaiveTime,
}
/// A DateTime that can be deserialized from a seconds-based timestamp
pub struct TsSeconds(NaiveDateTime);
impl From<TsSeconds> for NaiveDateTime {
/// Pull the internal NaiveDateTime out
fn from(obj: TsSeconds) -> NaiveDateTime {
obj.0
}
}
impl Deref for TsSeconds {
type Target = NaiveDateTime;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl NaiveDateTime {
/// Makes a new `NaiveDateTime` from date and time components.
/// Equivalent to [`date.and_time(time)`](./struct.NaiveDate.html#method.and_time)
@ -153,7 +135,7 @@ impl NaiveDateTime {
pub fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime> {
let (days, secs) = div_mod_floor(secs, 86400);
let date = days.to_i32().and_then(|days| days.checked_add(719163))
.and_then(|days_ce| NaiveDate::from_num_days_from_ce_opt(days_ce));
.and_then(NaiveDate::from_num_days_from_ce_opt);
let time = NaiveTime::from_num_seconds_from_midnight_opt(secs as u32, nsecs);
match (date, time) {
(Some(date), Some(time)) => Some(NaiveDateTime { date: date, time: time }),
@ -1121,6 +1103,7 @@ impl Timelike for NaiveDateTime {
///
/// Practically this also takes account of fractional seconds, so it is not recommended.
/// (For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
#[cfg_attr(feature = "cargo-clippy", allow(derive_hash_xor_eq))]
impl hash::Hash for NaiveDateTime {
fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.date.hash(state);
@ -1459,7 +1442,7 @@ fn test_decodable_json<F, E>(from_str: F)
#[cfg(all(test, feature = "rustc-serialize"))]
fn test_decodable_json_timestamp<F, E>(from_str: F)
where F: Fn(&str) -> Result<TsSeconds, E>, E: ::std::fmt::Debug
where F: Fn(&str) -> Result<rustc_serialize::TsSeconds, E>, E: ::std::fmt::Debug
{
assert_eq!(
*from_str("0").unwrap(),
@ -1474,8 +1457,9 @@ fn test_decodable_json_timestamp<F, E>(from_str: F)
}
#[cfg(feature = "rustc-serialize")]
mod rustc_serialize {
use super::{NaiveDateTime, TsSeconds};
pub mod rustc_serialize {
use std::ops::Deref;
use super::NaiveDateTime;
use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
impl Encodable for NaiveDateTime {
@ -1490,6 +1474,25 @@ mod rustc_serialize {
}
}
/// A `DateTime` that can be deserialized from a seconds-based timestamp
#[derive(Debug)]
pub struct TsSeconds(NaiveDateTime);
impl From<TsSeconds> for NaiveDateTime {
/// Pull the internal NaiveDateTime out
fn from(obj: TsSeconds) -> NaiveDateTime {
obj.0
}
}
impl Deref for TsSeconds {
type Target = NaiveDateTime;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl Decodable for TsSeconds {
fn decode<D: Decoder>(d: &mut D) -> Result<TsSeconds, D::Error> {
Ok(TsSeconds(
@ -1518,14 +1521,14 @@ mod rustc_serialize {
}
/// Tools to help serializing/deserializing NaiveDateTimes
/// Tools to help serializing/deserializing `NaiveDateTime`s
#[cfg(feature = "serde")]
pub mod serde {
use std::fmt;
use super::{NaiveDateTime};
use serdelib::{ser, de};
/// Serialize a NaiveDateTime as an RFC 3339 string
/// Serialize a `NaiveDateTime` as an RFC 3339 string
///
/// See [the `serde` module](./serde/index.html) for alternate
/// serialization formats.
@ -1613,7 +1616,7 @@ pub mod serde {
use NaiveDateTime;
/// Deserialize a DateTime from a seconds timestamp
/// Deserialize a `DateTime` from a seconds timestamp
///
/// Intended for use with `serde`s `deserialize_with` attribute.
///

6
src/naive/time.rs
View File

@ -518,6 +518,7 @@ impl NaiveTime {
/// (from_hms(20, 4, 5), -86400));
/// # }
/// ~~~~
#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
pub fn overflowing_add_signed(&self, mut rhs: OldDuration) -> (NaiveTime, i64) {
let mut secs = self.secs;
let mut frac = self.frac;
@ -545,13 +546,13 @@ impl NaiveTime {
let rhssecs = rhs.num_seconds();
let rhsfrac = (rhs - OldDuration::seconds(rhssecs)).num_nanoseconds().unwrap();
debug_assert!(OldDuration::seconds(rhssecs) + OldDuration::nanoseconds(rhsfrac) == rhs);
debug_assert_eq!(OldDuration::seconds(rhssecs) + OldDuration::nanoseconds(rhsfrac), rhs);
let rhssecsinday = rhssecs % 86400;
let mut morerhssecs = rhssecs - rhssecsinday;
let rhssecs = rhssecsinday as i32;
let rhsfrac = rhsfrac as i32;
debug_assert!(-86400 < rhssecs && rhssecs < 86400);
debug_assert!(morerhssecs % 86400 == 0);
debug_assert_eq!(morerhssecs % 86400, 0);
debug_assert!(-1_000_000_000 < rhsfrac && rhsfrac < 1_000_000_000);
let mut secs = secs as i32 + rhssecs;
@ -980,6 +981,7 @@ impl Timelike for NaiveTime {
///
/// Practically this also takes account of fractional seconds, so it is not recommended.
/// (For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
#[cfg_attr(feature = "cargo-clippy", allow(derive_hash_xor_eq))]
impl hash::Hash for NaiveTime {
fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.secs.hash(state);

2
src/offset/local.rs
View File

@ -77,7 +77,7 @@ fn datetime_to_timespec(d: &NaiveDateTime, local: bool) -> oldtime::Timespec {
/// let dt: DateTime<Local> = Local::now();
/// let dt: DateTime<Local> = Local.timestamp(0, 0);
/// ~~~~
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Debug)]
pub struct Local;
impl Local {