Whitespace fixes for dates code

base/dates/accessors.jl

@@ -3,62 +3,63 @@
 # Convert # of Rata Die days to proleptic Gregorian calendar y,m,d,w
 # Reference: http://mysite.verizon.net/aesir_research/date/date0.htm
 function yearmonthday(days)
-    z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
-    y = fld(100b+h,36525); c = b + z - 365y - fld(y,4); m = div(5c+456,153)
-    d = c - div(153m-457,5); return m > 12 ? (y+1,m-12,d) : (y,m,d)
+    z = days + 306; h = 100z - 25; a = fld(h, 3652425); b = a - fld(a, 4)
+    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
+    d = c - div(153m - 457, 5); return m > 12 ? (y + 1, m - 12, d) : (y, m, d)
 end
 function year(days)
-   z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
-   y = fld(100b+h,36525); c = b + z - 365y - fld(y,4); m = div(5c+456,153)
-   return m > 12 ? y+1 : y
+   z = days + 306; h = 100z - 25; a = fld(h, 3652425); b = a - fld(a, 4)
+   y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
+   return m > 12 ? y + 1 : y
 end
 function yearmonth(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
-    y = fld(100b+h,36525); c = b + z - 365y - fld(y,4); m = div(5c+456,153)
-    return m > 12 ? (y+1,m-12) : (y,m)
+    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
+    return m > 12 ? (y + 1, m - 12) : (y, m)
 end
 function month(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
-    y = fld(100b+h,36525); c = b + z - 365y - fld(y,4); m = div(5c+456,153)
-    return m > 12 ? m-12 : m
+    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
+    return m > 12 ? m - 12 : m
 end
 function monthday(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
-    y = fld(100b+h,36525); c = b + z - 365y - fld(y,4); m = div(5c+456,153)
-    d = c - div(153m-457,5); return m > 12 ? (m-12,d) : (m,d)
+    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
+    d = c - div(153m - 457, 5); return m > 12 ? (m - 12, d) : (m, d)
 end
 function day(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
-    y = fld(100b+h,36525); c = b + z - 365y - fld(y,4); m = div(5c+456,153)
-    return c - div(153m-457,5)
+    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
+    return c - div(153m - 457, 5)
 end
 # https://en.wikipedia.org/wiki/Talk:ISO_week_date#Algorithms
+const WEEK_INDEX = (15, 23, 3, 11)
 function week(days)
-    w = div(abs(days-1),7) % 20871
-    c,w = divrem((w + (w >= 10435)),5218)
-    w = (w*28+[15,23,3,11][c+1]) % 1461
-    return div(w,28) + 1
+    w = div(abs(days - 1), 7) % 20871
+    c, w = divrem((w + (w >= 10435)), 5218)
+    w = (w * 28 + WEEK_INDEX[c + 1]) % 1461
+    return div(w, 28) + 1
 end
 
 # Accessor functions
 value(dt::TimeType) = dt.instant.periods.value
 value(t::Time) = t.instant.value
 days(dt::Date) = value(dt)
-days(dt::DateTime) = fld(value(dt),86400000)
+days(dt::DateTime) = fld(value(dt), 86400000)
 year(dt::TimeType) = year(days(dt))
 month(dt::TimeType) = month(days(dt))
 week(dt::TimeType) = week(days(dt))
 day(dt::TimeType) = day(days(dt))
-hour(dt::DateTime)   = mod(fld(value(dt),3600000),24)
-minute(dt::DateTime) = mod(fld(value(dt),60000),60)
-second(dt::DateTime) = mod(fld(value(dt),1000),60)
-millisecond(dt::DateTime) = mod(value(dt),1000)
-hour(t::Time)   = mod(fld(value(t),3600000000000),Int64(24))
-minute(t::Time) = mod(fld(value(t),60000000000),Int64(60))
-second(t::Time) = mod(fld(value(t),1000000000),Int64(60))
-millisecond(t::Time) = mod(fld(value(t),Int64(1000000)),Int64(1000))
-microsecond(t::Time) = mod(fld(value(t),Int64(1000)),Int64(1000))
-nanosecond(t::Time) = mod(value(t),Int64(1000))
+hour(dt::DateTime)   = mod(fld(value(dt), 3600000), 24)
+minute(dt::DateTime) = mod(fld(value(dt), 60000), 60)
+second(dt::DateTime) = mod(fld(value(dt), 1000), 60)
+millisecond(dt::DateTime) = mod(value(dt), 1000)
+hour(t::Time)   = mod(fld(value(t), 3600000000000), Int64(24))
+minute(t::Time) = mod(fld(value(t), 60000000000), Int64(60))
+second(t::Time) = mod(fld(value(t), 1000000000), Int64(60))
+millisecond(t::Time) = mod(fld(value(t), Int64(1000000)), Int64(1000))
+microsecond(t::Time) = mod(fld(value(t), Int64(1000)), Int64(1000))
+nanosecond(t::Time) = mod(value(t), Int64(1000))
 
 dayofmonth(dt::TimeType) = day(dt)
 

base/dates/adjusters.jl

@@ -159,7 +159,7 @@ step size in adjusting can be provided manually through the `step` keyword. If
 `true`. `limit` provides a limit to the max number of iterations the adjustment API will
 pursue before throwing an error (given that `f::Function` is never satisfied).
 """
-function Date(func::Function, y, m=1, d=1;step::Period=Day(1), negate::Bool=false, limit::Int=10000)
+function Date(func::Function, y, m=1, d=1; step::Period=Day(1), negate::Bool=false, limit::Int=10000)
     return adjust(DateFunction(func, negate, Date(y, m, d)), Date(y, m, d), step, limit)
 end
 
@@ -215,7 +215,7 @@ function Time(func::Function, h, mi, s; step::Period=Millisecond(1), negate::Boo
     return adjust(DateFunction(func, negate, Time(h, mi, s)), Time(h, mi, s), step, limit)
 end
 function Time(func::Function, h, mi, s, ms; step::Period=Microsecond(1), negate::Bool=false, limit::Int=10000)
-    return adjust(DateFunction(func, negate,Time(h, mi, s, ms)),Time(h, mi, s, ms), step, limit)
+    return adjust(DateFunction(func, negate, Time(h, mi, s, ms)), Time(h, mi, s, ms), step, limit)
 end
 function Time(func::Function, h, mi, s, ms, us; step::Period=Nanosecond(1), negate::Bool=false, limit::Int=10000)
     return adjust(DateFunction(func, negate, Time(h, mi, s, ms, us)), Time(h, mi, s, ms, us), step, limit)
@@ -232,35 +232,35 @@ ISDAYOFWEEK = Dict(Mon => DateFunction(ismonday, false, Date(0)),
 
 # "same" indicates whether the current date can be considered or not
 """
-    tonext(dt::TimeType,dow::Int;same::Bool=false) -> TimeType
+    tonext(dt::TimeType, dow::Int; same::Bool=false) -> TimeType
 
 Adjusts `dt` to the next day of week corresponding to `dow` with `1 = Monday, 2 = Tuesday,
 etc`. Setting `same=true` allows the current `dt` to be considered as the next `dow`,
 allowing for no adjustment to occur.
 """
-tonext(dt::TimeType, dow::Int; same::Bool=false) = adjust(ISDAYOFWEEK[dow], same ? dt : dt+Day(1), Day(1), 7)
+tonext(dt::TimeType, dow::Int; same::Bool=false) = adjust(ISDAYOFWEEK[dow], same ? dt : dt + Day(1), Day(1), 7)
 
 # Return the next TimeType where func evals true using step in incrementing
 """
-    tonext(func::Function,dt::TimeType;step=Day(1),negate=false,limit=10000,same=false) -> TimeType
+    tonext(func::Function, dt::TimeType; step=Day(1), negate=false, limit=10000, same=false) -> TimeType
 
 Adjusts `dt` by iterating at most `limit` iterations by `step` increments until `func`
 returns `true`. `func` must take a single `TimeType` argument and return a `Bool`. `same`
 allows `dt` to be considered in satisfying `func`. `negate` will make the adjustment process
 terminate when `func` returns `false` instead of `true`.
 """
-function tonext(func::Function, dt::TimeType;step::Period=Day(1), negate::Bool=false, limit::Int=10000, same::Bool=false)
-    return adjust(DateFunction(func, negate, dt), same ? dt : dt+step, step, limit)
+function tonext(func::Function, dt::TimeType; step::Period=Day(1), negate::Bool=false, limit::Int=10000, same::Bool=false)
+    return adjust(DateFunction(func, negate, dt), same ? dt : dt + step, step, limit)
 end
 
 """
-    toprev(dt::TimeType,dow::Int;same::Bool=false) -> TimeType
+    toprev(dt::TimeType, dow::Int; same::Bool=false) -> TimeType
 
 Adjusts `dt` to the previous day of week corresponding to `dow` with `1 = Monday, 2 =
 Tuesday, etc`. Setting `same=true` allows the current `dt` to be considered as the previous
 `dow`, allowing for no adjustment to occur.
 """
-toprev(dt::TimeType, dow::Int; same::Bool=false) = adjust(ISDAYOFWEEK[dow], same ? dt : dt+Day(-1), Day(-1), 7)
+toprev(dt::TimeType, dow::Int; same::Bool=false) = adjust(ISDAYOFWEEK[dow], same ? dt : dt + Day(-1), Day(-1), 7)
 
 """
     toprev(func::Function,dt::TimeType;step=Day(-1),negate=false,limit=10000,same=false) -> TimeType
@@ -271,12 +271,12 @@ allows `dt` to be considered in satisfying `func`. `negate` will make the adjust
 terminate when `func` returns `false` instead of `true`.
 """
 function toprev(func::Function, dt::TimeType; step::Period=Day(-1), negate::Bool=false, limit::Int=10000, same::Bool=false)
-    return adjust(DateFunction(func, negate, dt), same ? dt : dt+step, step, limit)
+    return adjust(DateFunction(func, negate, dt), same ? dt : dt + step, step, limit)
 end
 
 # Return the first TimeType that falls on dow in the Month or Year
 """
-    tofirst(dt::TimeType,dow::Int;of=Month) -> TimeType
+    tofirst(dt::TimeType, dow::Int; of=Month) -> TimeType
 
 Adjusts `dt` to the first `dow` of its month. Alternatively, `of=Year` will adjust to the
 first `dow` of the year.
@@ -288,7 +288,7 @@ end
 
 # Return the last TimeType that falls on dow in the Month or Year
 """
-    tolast(dt::TimeType,dow::Int;of=Month) -> TimeType
+    tolast(dt::TimeType, dow::Int; of=Month) -> TimeType
 
 Adjusts `dt` to the last `dow` of its month. Alternatively, `of=Year` will adjust to the
 last `dow` of the year.

base/dates/conversions.jl

@@ -9,15 +9,15 @@ Converts a `DateTime` to a `Date`. The hour, minute, second, and millisecond par
 the `DateTime` are truncated, so only the year, month and day parts are used in
 construction.
 """
-Date(dt::TimeType) = convert(Date,dt)
+Date(dt::TimeType) = convert(Date, dt)
 
 """
     DateTime(dt::Date) -> DateTime
 
 Converts a `Date` to a `DateTime`. The hour, minute, second, and millisecond parts of
 the new `DateTime` are assumed to be zero.
 """
-DateTime(dt::TimeType) = convert(DateTime,dt)
+DateTime(dt::TimeType) = convert(DateTime, dt)
 
 """
     Time(dt::DateTime) -> Time
@@ -27,7 +27,7 @@ the `DateTime` are used to create the new `Time`. Microsecond and nanoseconds ar
 """
 Time(dt::DateTime) = convert(Time, dt)
 
-Base.convert(::Type{DateTime}, dt::Date) = DateTime(UTM(value(dt)*86400000))
+Base.convert(::Type{DateTime}, dt::Date) = DateTime(UTM(value(dt) * 86400000))
 Base.convert(::Type{Date}, dt::DateTime) = Date(UTD(days(dt)))
 Base.convert(::Type{Time}, dt::DateTime) = Time(Nanosecond((value(dt) % 86400000) * 1000000))
 
@@ -36,13 +36,13 @@ Base.convert(::Type{Time}, dt::DateTime) = Time(Nanosecond((value(dt) % 86400000
 Converts a DateTime value `dt` to a number of type `T`. The returned value corresponds to the number of Rata Die milliseconds since epoch.
 See `convert(DateTime, x::Real)` for inverse.
 """
-Base.convert{R<:Real}(::Type{R},x::DateTime) = convert(R,value(x))
+Base.convert{R<:Real}(::Type{R},x::DateTime) = convert(R, value(x))
 """
     convert{T<:Real}(::Type{T}, dt::Date) -> T
 Converts a Date value `dt` to a number of type `T`. The returned value corresponds to the number of Rata Die days since epoch.
 See `convert(Date, x::Real)` for inverse.
 """
-Base.convert{R<:Real}(::Type{R},x::Date)     = convert(R,value(x))
+Base.convert{R<:Real}(::Type{R},x::Date)     = convert(R, value(x))
 """
     convert{T<:Real}(::Type{DateTime}, x::T) -> DateTime
 Converts a number of type `T` to a DateTime. `x` should be the number of Rata Die milliseconds since epoch.
@@ -75,7 +75,7 @@ end
 Takes the given `DateTime` and returns the number of seconds
 since the unix epoch `1970-01-01T00:00:00` as a `Float64`.
 """
-datetime2unix(dt::DateTime) = (value(dt) - UNIXEPOCH)/1000.0
+datetime2unix(dt::DateTime) = (value(dt) - UNIXEPOCH) / 1000.0
 
 """
     now() -> DateTime
@@ -86,7 +86,7 @@ locale.
 function now()
     tv = Libc.TimeVal()
     tm = Libc.TmStruct(tv.sec)
-    return DateTime(tm.year+1900,tm.month+1,tm.mday,tm.hour,tm.min,tm.sec,div(tv.usec,1000))
+    return DateTime(tm.year + 1900, tm.month + 1, tm.mday, tm.hour, tm.min, tm.sec, div(tv.usec, 1000))
 end
 
 """
@@ -119,7 +119,7 @@ Returns the number of Rata Die days since epoch from the given `Date` or `DateTi
 datetime2rata(dt::TimeType) = days(dt)
 
 # Julian conversions
-const JULIANEPOCH = value(DateTime(-4713,11,24,12))
+const JULIANEPOCH = value(DateTime(-4713, 11, 24, 12))
 
 """
     julian2datetime(julian_days) -> DateTime
@@ -138,4 +138,4 @@ end
 Takes the given `DateTime` and returns the number of Julian calendar days since the julian
 epoch `-4713-11-24T12:00:00` as a `Float64`.
 """
-datetime2julian(dt::DateTime) = (value(dt) - JULIANEPOCH)/86400000.0
+datetime2julian(dt::DateTime) = (value(dt) - JULIANEPOCH) / 86400000.0