diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..23ee24c --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.DS_Store +target/ \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f433b1a --- /dev/null +++ b/LICENSE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..11565dd --- /dev/null +++ b/pom.xml @@ -0,0 +1,121 @@ + + 4.0.0 + org.scala-tools + time + jar + Scala-Time + 0.1-SNAPSHOT + http://github.com/jorgeortiz85/scala-javautils + 2009 + A simple Scala wrapper for Joda Time + + + Apache License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0 + repo + + + + scm:git:git://github.com/jorgeortiz85/scala-time.git + scm:git:git@github.com:jorgeortiz85/scala-time.git + http://github.com/jorgeortiz85/scala-time + + + + 2.7.3 + + + + + scala-tools.org + Scala-Tools Maven2 Repository + http://scala-tools.org/repo-releases + + + + + + scala-tools.org + Scala-Tools Maven2 Repository + http://scala-tools.org/repo-releases + + + + + + org.scala-lang + scala-library + ${scala.version} + + + joda-time + joda-time + 1.6 + + + + + + src/main/scala + src/test/scala + + + org.scala-tools + maven-scala-plugin + + + + compile + testCompile + + + + + ${scala.version} + + -target:jvm-1.5 + + + + + org.apache.maven.plugins + maven-eclipse-plugin + + true + + ch.epfl.lamp.sdt.core.scalabuilder + + + ch.epfl.lamp.sdt.core.scalanature + + + org.eclipse.jdt.launching.JRE_CONTAINER + ch.epfl.lamp.sdt.launching.SCALA_CONTAINER + + + + + + + + + org.scala-tools + maven-scala-plugin + + ${scala.version} + + + + + diff --git a/src/main/scala/org/scala_tools/time/Implicits.scala b/src/main/scala/org/scala_tools/time/Implicits.scala new file mode 100644 index 0000000..30400ae --- /dev/null +++ b/src/main/scala/org/scala_tools/time/Implicits.scala @@ -0,0 +1,48 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import java.util.Locale +import org.joda.time._ +import org.joda.time.field.AbstractReadableInstantFieldProperty + +object Implicits extends Implicits +object IntImplicits extends IntImplicits +object JodaImplicits extends JodaImplicits + +trait Implicits extends IntImplicits with JodaImplicits + +trait IntImplicits { + implicit def intHelpers(n: Int) = new IntHelpers(n) +} + +trait JodaImplicits { + implicit def richAbstractReadableInstantFieldProperty(pty: AbstractReadableInstantFieldProperty) = + new RichAbstractReadableInstantFieldProperty(pty) + implicit def richChronology(ch: Chronology) = new RichChronology(ch) + implicit def richDateMidnight(dm: DateMidnight) = new RichDateMidnight(dm) + implicit def richDateTime(dt: DateTime) = new RichDateTime(dt) + implicit def richDateTimeProperty(pty: DateTime.Property) = new RichDateTimeProperty(pty) + implicit def richDateTimeZone(zone: DateTimeZone) = new RichDateTimeZone(zone) + implicit def richDuration(dur: Duration) = new RichDuration(dur) + implicit def richInstant(in: Instant) = new RichInstant(in) + implicit def richPeriod(per: Period) = new RichPeriod(per) + implicit def richReadableDuration(dur: ReadableDuration) = new RichReadableDuration(dur) + implicit def richReadableInstant(in: ReadableInstant) = new RichReadableInstant(in) + implicit def richReadableInterval(in: ReadableInterval) = new RichReadableInterval(in) + implicit def richReadablePeriod(per: ReadablePeriod) = new RichReadablePeriod(per) +} \ No newline at end of file diff --git a/src/main/scala/org/scala_tools/time/Instants.scala b/src/main/scala/org/scala_tools/time/Instants.scala new file mode 100644 index 0000000..c4b4de4 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/Instants.scala @@ -0,0 +1,44 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ +import org.scala_tools.time.Implicits._ + +object Instants extends Instants + +trait Instants { + def now = new DateTime + + def nextSecond = now + 1.second + def nextMinute = now + 1.minute + def nextHour = now + 1.hour + def nextDay = now + 1.day + def tomorrow = now + 1.day + def nextWeek = now + 1.week + def nextMonth = now + 1.month + def nextYear = now + 1.year + + def lastSecond = now - 1.second + def lastMinute = now - 1.minute + def lastHour = now - 1.hour + def lastDay = now - 1.day + def yesterday = now - 1.day + def lastWeek = now - 1.week + def lastMonth = now - 1.month + def lastYear = now - 1.year +} diff --git a/src/main/scala/org/scala_tools/time/IntHelpers.scala b/src/main/scala/org/scala_tools/time/IntHelpers.scala new file mode 100644 index 0000000..8f07ef2 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/IntHelpers.scala @@ -0,0 +1,39 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class IntHelpers(n: Int) { + def millis: Period = Period.millis(n) + def seconds: Period = Period.seconds(n) + def minutes: Period = Period.minutes(n) + def hours: Period = Period.hours(n) + def days: Period = Period.days(n) + def weeks: Period = Period.weeks(n) + def months: Period = Period.months(n) + def years: Period = Period.years(n) + + def milli: Period = Period.millis(n) + def second: Period = Period.seconds(n) + def minute: Period = Period.minutes(n) + def hour: Period = Period.hours(n) + def day: Period = Period.days(n) + def week: Period = Period.weeks(n) + def month: Period = Period.months(n) + def year: Period = Period.years(n) +} diff --git a/src/main/scala/org/scala_tools/time/Intervals.scala b/src/main/scala/org/scala_tools/time/Intervals.scala new file mode 100644 index 0000000..cfaa4ed --- /dev/null +++ b/src/main/scala/org/scala_tools/time/Intervals.scala @@ -0,0 +1,51 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.scala_tools.time.Implicits._ +import org.joda.time._ + +object Intervals extends Intervals + +trait Intervals { + def thisSecond = Instants.now.second.interval + def thisMinute = Instants.now.minute.interval + def thisHour = Instants.now.hour.interval + def thisDay = Instants.now.day.interval + def today = Instants.now.day.interval + def thisWeek = Instants.now.week.interval + def thisMonth = Instants.now.month.interval + def thisYear = Instants.now.year.interval + + def nextSecond = Instants.nextSecond.second.interval + def nextMinute = Instants.nextMinute.minute.interval + def nextHour = Instants.nextHour.hour.interval + def nextDay = Instants.nextDay.day.interval + def tomorrow = Instants.nextDay.day.interval + def nextWeek = Instants.nextWeek.week.interval + def nextMonth = Instants.nextMonth.month.interval + def nextYear = Instants.nextYear.year.interval + + def lastSecond = Instants.lastSecond.second.interval + def lastMinute = Instants.lastMinute.minute.interval + def lastHour = Instants.lastHour.hour.interval + def lastDay = Instants.lastDay.day.interval + def yesterday = Instants.lastDay.day.interval + def lastWeek = Instants.lastWeek.week.interval + def lastMonth = Instants.lastMonth.month.interval + def lastYear = Instants.lastYear.year.interval +} diff --git a/src/main/scala/org/scala_tools/time/RichAbstractReadableInstantFieldProperty.scala b/src/main/scala/org/scala_tools/time/RichAbstractReadableInstantFieldProperty.scala new file mode 100644 index 0000000..c42e4fe --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichAbstractReadableInstantFieldProperty.scala @@ -0,0 +1,75 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import java.util.Locale +import org.joda.time._ +import org.joda.time.field.AbstractReadableInstantFieldProperty + +class RichAbstractReadableInstantFieldProperty(pty: AbstractReadableInstantFieldProperty) { + def shortText: String = + pty.getAsShortText + def asShortText: String = + pty.getAsShortText + def shortText(locale: Locale): String = + pty.getAsShortText(locale) + def asShortText(locale: Locale): String = + pty.getAsShortText(locale) + def asString: String = + pty.getAsString + def text: String = + pty.getAsText + def asText: String = + pty.getAsText + def text(locale: Locale): String = + pty.getAsText(locale) + def asText(locale: Locale): String = + pty.getAsText(locale) + def durationField: DurationField = + pty.getDurationField + def field: DateTimeField = + pty.getField + def fieldType: DateTimeFieldType = + pty.getFieldType + def leapAmount: Int = + pty.getLeapAmount + def leapDurationField: DurationField = + pty.getLeapDurationField + def maximumValue: Int = + pty.getMaximumValue + def maxValue: Int = + pty.getMaximumValue + def maximumValueOverall: Int = + pty.getMaximumValueOverall + def maxValueOverall: Int = + pty.getMaximumValueOverall + def minimumValue: Int = + pty.getMinimumValue + def minValue: Int = + pty.getMinimumValue + def minimumValueOverall: Int = + pty.getMinimumValueOverall + def minValueOverall: Int = + pty.getMinimumValueOverall + def name: String = + pty.getName + def rangeDurationField: DurationField = + pty.getRangeDurationField + + def interval: Interval = + pty.toInterval +} diff --git a/src/main/scala/org/scala_tools/time/RichChronology.scala b/src/main/scala/org/scala_tools/time/RichChronology.scala new file mode 100644 index 0000000..68b8500 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichChronology.scala @@ -0,0 +1,26 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichChronology(ch: Chronology) { + def zone: Option[DateTimeZone] = + nullCheck(ch.getZone) + private def nullCheck[T <: AnyRef](x: T): Option[T] = + if (x == null) None else Some(x) +} diff --git a/src/main/scala/org/scala_tools/time/RichDateMidnight.scala b/src/main/scala/org/scala_tools/time/RichDateMidnight.scala new file mode 100644 index 0000000..9b46edd --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichDateMidnight.scala @@ -0,0 +1,34 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichDateMidnight(dm: DateMidnight) { + def -(duration: Long): DateMidnight = + dm.minus(duration) + def -(duration: ReadableDuration): DateMidnight = + dm.minus(duration) + def -(period: ReadablePeriod): DateMidnight = + dm.minus(period) + def +(duration: Long): DateMidnight = + dm.plus(duration) + def +(duration: ReadableDuration): DateMidnight = + dm.plus(duration) + def +(period: ReadablePeriod): DateMidnight = + dm.plus(period) +} diff --git a/src/main/scala/org/scala_tools/time/RichDateTime.scala b/src/main/scala/org/scala_tools/time/RichDateTime.scala new file mode 100644 index 0000000..70f57b3 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichDateTime.scala @@ -0,0 +1,44 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichDateTime(dt: DateTime) { + def -(duration: Long): DateTime = + dt.minus(duration) + def -(duration: ReadableDuration): DateTime = + dt.minus(duration) + def -(period: ReadablePeriod): DateTime = + dt.minus(period) + def +(duration: Long): DateTime = + dt.plus(duration) + def +(duration: ReadableDuration): DateTime = + dt.plus(duration) + def +(period: ReadablePeriod): DateTime = + dt.plus(period) + + def millis = dt.millisOfSecond + def second = dt.secondOfMinute + def minute = dt.minuteOfHour + def hour = dt.hourOfDay + def day = dt.dayOfMonth + def week = dt.weekOfWeekyear + def month = dt.monthOfYear + def year = dt.year + def century = dt.centuryOfEra +} diff --git a/src/main/scala/org/scala_tools/time/RichDateTimeProperty.scala b/src/main/scala/org/scala_tools/time/RichDateTimeProperty.scala new file mode 100644 index 0000000..2c70d95 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichDateTimeProperty.scala @@ -0,0 +1,24 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichDateTimeProperty(pty: DateTime.Property) { + def dateTime: DateTime = + pty.getDateTime +} diff --git a/src/main/scala/org/scala_tools/time/RichDateTimeZone.scala b/src/main/scala/org/scala_tools/time/RichDateTimeZone.scala new file mode 100644 index 0000000..e8b1ebd --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichDateTimeZone.scala @@ -0,0 +1,24 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichDateTimeZone(dtz: DateTimeZone) { + def id: String = + dtz.getID +} diff --git a/src/main/scala/org/scala_tools/time/RichDuration.scala b/src/main/scala/org/scala_tools/time/RichDuration.scala new file mode 100644 index 0000000..a21f9ef --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichDuration.scala @@ -0,0 +1,32 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichDuration(dur: Duration) { + def seconds: Long = + dur.getStandardSeconds + def -(amount: Long): Duration = + dur.minus(amount) + def -(amount: ReadableDuration): Duration = + dur.minus(amount) + def +(amount: Long): Duration = + dur.plus(amount) + def +(amount: ReadableDuration): Duration = + dur.plus(amount) +} diff --git a/src/main/scala/org/scala_tools/time/RichInstant.scala b/src/main/scala/org/scala_tools/time/RichInstant.scala new file mode 100644 index 0000000..9c4e827 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichInstant.scala @@ -0,0 +1,30 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichInstant(instant: Instant) { + def -(duration: Long): Instant = + instant.minus(duration) + def -(duration: ReadableDuration): Instant = + instant.minus(duration) + def +(duration: Long): Instant = + instant.plus(duration) + def +(duration: ReadableDuration): Instant = + instant.plus(duration) +} diff --git a/src/main/scala/org/scala_tools/time/RichPeriod.scala b/src/main/scala/org/scala_tools/time/RichPeriod.scala new file mode 100644 index 0000000..02d0eb3 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichPeriod.scala @@ -0,0 +1,46 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichPeriod(pd: Period) { + def days: Int = + pd.getDays + def hours: Int = + pd.getHours + def millis: Int = + pd.getMillis + def minutes: Int = + pd.getMinutes + def months: Int = + pd.getMonths + def seconds: Int = + pd.getSeconds + def weeks: Int = + pd.getWeeks + def years: Int = + pd.getYears + def -(period: ReadablePeriod): Period = + pd.minus(period) + def +(period: ReadablePeriod): Period = + pd.plus(period) + def ago: DateTime = + Instants.now.minus(pd) + def from(dt: DateTime): DateTime = + dt.plus(pd) +} diff --git a/src/main/scala/org/scala_tools/time/RichReadableDuration.scala b/src/main/scala/org/scala_tools/time/RichReadableDuration.scala new file mode 100644 index 0000000..3db915f --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichReadableDuration.scala @@ -0,0 +1,26 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichReadableDuration[T <: ReadableDuration](dur: T) extends Ordered[T] { + def millis: Long = + dur.getMillis + def compare(other: T): Int = + dur.compareTo(other) +} diff --git a/src/main/scala/org/scala_tools/time/RichReadableInstant.scala b/src/main/scala/org/scala_tools/time/RichReadableInstant.scala new file mode 100644 index 0000000..0e8f84c --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichReadableInstant.scala @@ -0,0 +1,30 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichReadableInstant[T <: ReadableInstant](instant: T) extends Ordered[T] { + def chronology: Chronology = + instant.getChronology + def millis: Long = + instant.getMillis + def zone: DateTimeZone = + instant.getZone + override def compare(that: T): Int = + instant.compareTo(that) +} diff --git a/src/main/scala/org/scala_tools/time/RichReadableInterval.scala b/src/main/scala/org/scala_tools/time/RichReadableInterval.scala new file mode 100644 index 0000000..165cfc7 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichReadableInterval.scala @@ -0,0 +1,31 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichReadableInterval(iv: ReadableInterval) { + def chronology: Chronology = + iv.getChronology + def end: DateTime = + iv.getEnd + def start: DateTime = + iv.getStart + + // TODO: Should > and > be added as aliases for isAfter and isBefore? + // could be convenient, or just confusing because this isn't Ordered. +} diff --git a/src/main/scala/org/scala_tools/time/RichReadablePeriod.scala b/src/main/scala/org/scala_tools/time/RichReadablePeriod.scala new file mode 100644 index 0000000..c2cd0a2 --- /dev/null +++ b/src/main/scala/org/scala_tools/time/RichReadablePeriod.scala @@ -0,0 +1,24 @@ +/** + * Copyright 2009 Jorge Ortiz + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + **/ +package org.scala_tools.time + +import org.joda.time._ + +class RichReadablePeriod(pd: ReadablePeriod) { + def periodType: PeriodType = + pd.getPeriodType +} diff --git a/src/test/scala/org/scala_tools/time/AppTest.scala b/src/test/scala/org/scala_tools/time/AppTest.scala new file mode 100644 index 0000000..346520e --- /dev/null +++ b/src/test/scala/org/scala_tools/time/AppTest.scala @@ -0,0 +1,17 @@ +// package org.scala_tools.time +// +// import org.junit._ +// import Assert._ +// +// @Test +// class AppTest { +// +// @Test +// def testOK() = assertTrue(true) +// +// // @Test +// // def testKO() = assertTrue(false) +// +// } +// +// diff --git a/src/test/scala/org/scala_tools/time/MySpec.scala b/src/test/scala/org/scala_tools/time/MySpec.scala new file mode 100644 index 0000000..98f72fc --- /dev/null +++ b/src/test/scala/org/scala_tools/time/MySpec.scala @@ -0,0 +1,17 @@ +// package org.scala_tools.time +// +// import org.specs._ +// import org.specs.runner.{ConsoleRunner, JUnit4} +// +// class MySpecTest extends JUnit4(MySpec) +// //class MySpecSuite extends ScalaTestSuite(MySpec) +// object MySpecRunner extends ConsoleRunner(MySpec) +// +// object MySpec extends Specification { +// "This wonderful system" should { +// "save the world" in { +// val list = Nil +// list must beEmpty +// } +// } +// }