From e979eef1f454a5f5654060eec50af3696239cde9 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 12:38:16 +0100 Subject: [PATCH 1/7] Asymptopically approaching acceptable names. "org.scala-lang.modules" %% "scala-compat-jdk8" import scala.compat.jdk8._ Subsequent commits will address the under-loved `JFunc`. --- README.md | 28 +++++++++++++------ build.sbt | 8 ++++-- project/CodeGen.scala | 2 +- .../Test.java => compat/jdk8/LambdaTest.java} | 9 +++--- 4 files changed, 32 insertions(+), 15 deletions(-) rename src/test/java/scala/{runtime/jfunc/Test.java => compat/jdk8/LambdaTest.java} (97%) diff --git a/README.md b/README.md index 79c2901..fef188e 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,16 @@ -## Functional Interfaces for Scala functions +## JDK8 Compatibility Kit for Scala + +### Functional Interfaces for Scala functions A set of [Functional Interfaces](http://download.java.net/jdk8/docs/api/java/lang/FunctionalInterface.html) for `scala.FunctionN`. These are designed for convenient construction of Scala functions using Java 8 lambda syntax. -### Usage +#### Usage ```java import scala.concurrent.*; -import static scala.runtime.jfunc.JFunc.*; +import static scala.compat.jdk8.JFunc.*; class Test { private static Future futureExample(Future future, ExecutionContext ec) { @@ -17,16 +19,28 @@ class Test { } ``` -[More Examples / Documentation](https://github.com/retronym/java-8-function1/blob/master/src/test/java/scala/runtime/jfunc/Test.java) +[More Examples / Documentation](https://github.com/scala/scala-compat-jdk8/blob/master/src/test/java/scala/compat/jdk8/LambdaTest.java) + +### Converters between `s.u.concurrent` and `j.u.concurrent` + +TODO + +### Converters for `j.u.function` + +TODO + +### Converters for `j.u.Stream` + +TODO ### Hacking -[Code Generator](https://github.com/retronym/java-8-function1/blob/master/project/CodeGen.scala) +[Code Generator](https://github.com/scala/scala-compat-jdk8/blob/master/project/CodeGen.scala) #### Running Examples ``` -% (export JAVA_HOME=`java_home 1.8`; export PATH=$JAVA_HOME/bin:$PATH; sbt 'test:runMain scala.runtime.test.Test') +% (export JAVA_HOME=`java_home 1.8`; export PATH=$JAVA_HOME/bin:$PATH; sbt 'test:runMain scala.compat.jdk8.LambdaTest') ``` ### Future work @@ -35,8 +49,6 @@ class Test { modify scalac to emit lambdas as calls to the lambda MetaFactory against them. ```java -package scala.runtime; - @FunctionalInterface public interface JFunction1$mcII$sp extends JFunction1 { abstract int apply$mcII$sp(int v1); diff --git a/build.sbt b/build.sbt index 45d3ab9..bbb93f6 100644 --- a/build.sbt +++ b/build.sbt @@ -1,8 +1,12 @@ scalaVersion := "2.10.3" +organization := "org.scala-lang.modules" + +name := "scala-compat-jdk8" + sourceGenerators in Compile <+= sourceManaged in Compile map { dir => def write(name: String, content: String) = { - val f = dir / "java" / "scala" / "runtime" / "jfunc" / s"${name}.java" + val f = dir / "java" / "scala" / "compat" / "jdk8" / s"${name}.java" IO.write(f, content) f } @@ -11,7 +15,7 @@ sourceGenerators in Compile <+= sourceManaged in Compile map { dir => sourceGenerators in Test <+= sourceManaged in Test map { dir => def write(name: String, content: String) = { - val f = dir / "java" / "scala" / "runtime" / "jfunc" / s"${name}.java" + val f = dir / "java" / "scala" / "compat" / "jdk8" / s"${name}.java" IO.write(f, content) f } diff --git a/project/CodeGen.scala b/project/CodeGen.scala index adec5e7..41f70eb 100644 --- a/project/CodeGen.scala +++ b/project/CodeGen.scala @@ -17,7 +17,7 @@ object Type { } object CodeGen { - def packaging = "package scala.runtime.jfunc;" + def packaging = "package scala.compat.jdk8;" case class arity(n: Int) { val ns = (1 to n).toList diff --git a/src/test/java/scala/runtime/jfunc/Test.java b/src/test/java/scala/compat/jdk8/LambdaTest.java similarity index 97% rename from src/test/java/scala/runtime/jfunc/Test.java rename to src/test/java/scala/compat/jdk8/LambdaTest.java index c0a2ca2..12ee3a6 100644 --- a/src/test/java/scala/runtime/jfunc/Test.java +++ b/src/test/java/scala/compat/jdk8/LambdaTest.java @@ -1,13 +1,13 @@ /* * Copyright (C) 2012-2014 Typesafe Inc. */ -package scala.runtime.jfunc; +package scala.compat.jdk8; import scala.runtime.*; -import static scala.runtime.jfunc.TestAPI.*; -import static scala.runtime.jfunc.JFunc.*; +import static scala.compat.jdk8.TestAPI.*; +import static scala.compat.jdk8.JFunc.*; -public class Test { +public class LambdaTest { public static void main(String[] args) { // Not allowed with Scala 2.10 nor 2.11 // "incompatible types: Function1 is not a functional interface" @@ -108,3 +108,4 @@ private static String join(String... ss) { return result; } } + From 597ed637c9bdfc998b15a4459be3365d0f0ca1a6 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 12:39:27 +0100 Subject: [PATCH 2/7] Relicense under the Scala license. In accordance with the move to the Scala github organization and the plan to release this under "org.scala-lang.modules". --- LICENSE | 233 +++++++------------------------------------------------- 1 file changed, 28 insertions(+), 205 deletions(-) diff --git a/LICENSE b/LICENSE index 3480a55..ce51bda 100644 --- a/LICENSE +++ b/LICENSE @@ -1,205 +1,28 @@ -Copyright (C) 2014 Typesafe, Inc. -Copyright (C) 2014 EPFL - - - 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 - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - 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. +Copyright (c) 2002-2013 EPFL +Copyright (c) 2011-2013 Typesafe, Inc. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of the EPFL nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. From 89a660ec28e976b26393c80b8556b347d3c6dec9 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 12:53:19 +0100 Subject: [PATCH 3/7] Rename JFunc to JFunction. So as to avoid the inconsistent abbreviation with `JFunctionN`. --- build.sbt | 2 +- project/CodeGen.scala | 4 ++-- src/test/java/scala/compat/jdk8/LambdaTest.java | 7 +++---- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/build.sbt b/build.sbt index bbb93f6..cc77aca 100644 --- a/build.sbt +++ b/build.sbt @@ -10,7 +10,7 @@ sourceGenerators in Compile <+= sourceManaged in Compile map { dir => IO.write(f, content) f } - Seq(write("JFunc", CodeGen.factory)) ++ (0 to 22).map(n => write("JFunction" + n, CodeGen.fN(n))) ++ (1 to 22).map(n => write("JProcedure" + n, CodeGen.pN(n))) + Seq(write("JFunction", CodeGen.factory)) ++ (0 to 22).map(n => write("JFunction" + n, CodeGen.fN(n))) ++ (1 to 22).map(n => write("JProcedure" + n, CodeGen.pN(n))) } sourceGenerators in Test <+= sourceManaged in Test map { dir => diff --git a/project/CodeGen.scala b/project/CodeGen.scala index 41f70eb..1d55c4c 100644 --- a/project/CodeGen.scala +++ b/project/CodeGen.scala @@ -278,8 +278,8 @@ object CodeGen { | |import scala.runtime.BoxedUnit; | - |public final class JFunc { - | private JFunc() {} + |public final class JFunction { + | private JFunction() {} | public static scala.Function0 func(JFunction0 f) { return f; } |${indent(ms)} |} diff --git a/src/test/java/scala/compat/jdk8/LambdaTest.java b/src/test/java/scala/compat/jdk8/LambdaTest.java index 12ee3a6..f19a24e 100644 --- a/src/test/java/scala/compat/jdk8/LambdaTest.java +++ b/src/test/java/scala/compat/jdk8/LambdaTest.java @@ -5,7 +5,7 @@ import scala.runtime.*; import static scala.compat.jdk8.TestAPI.*; -import static scala.compat.jdk8.JFunc.*; +import static scala.compat.jdk8.JFunction.*; public class LambdaTest { public static void main(String[] args) { @@ -40,7 +40,7 @@ public static void main(String[] args) { // F1 is a subclass of Function1: scala.Function1 f2 = f1; - // Factory methods in `JFunc` can reduce the verbosity a little: + // Factory methods in `JFunction` can reduce the verbosity a little: // `func` is actually just an identity method; it only exists to // trigger lambda creation using the `JFunction1` functional interface. scala.Function1 f3 = func((String s) -> s); @@ -65,7 +65,7 @@ public static void main(String[] args) { // Functions returning unit must use the `JProcedure1`, ... functional interfaces // in order to convert a void lamdba return to Scala's Unit. // - // The easiest way to do this is via `JFunc.proc`, .... + // The easiest way to do this is via `JFunction.proc`, .... // // Note that the lambda has a return type of `void` if the last // statement is a call to a `void` returning method, or if it is @@ -108,4 +108,3 @@ private static String join(String... ss) { return result; } } - From 4c0c10640d4d3056dda2d713c31c27e258496bb1 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 13:03:53 +0100 Subject: [PATCH 4/7] Get the build into shape for a Scala module - add the scala-modules SBT plugin - configure OSGi package export - Check that SBT is running on Java8, rather than waiting for cryptic build errors. - convert `LambdaTest` to a JUnit test. --- README.md | 2 +- build.sbt | 36 ++++++++++++++++++- project/plugins.sbt | 3 ++ .../java/scala/compat/jdk8/LambdaTest.java | 4 ++- 4 files changed, 42 insertions(+), 3 deletions(-) create mode 100644 project/plugins.sbt diff --git a/README.md b/README.md index fef188e..1c6b91c 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ TODO #### Running Examples ``` -% (export JAVA_HOME=`java_home 1.8`; export PATH=$JAVA_HOME/bin:$PATH; sbt 'test:runMain scala.compat.jdk8.LambdaTest') +% (export JAVA_HOME=`java_home 1.8`; export PATH=$JAVA_HOME/bin:$PATH; sbt test) ``` ### Future work diff --git a/build.sbt b/build.sbt index cc77aca..3f767ab 100644 --- a/build.sbt +++ b/build.sbt @@ -1,9 +1,36 @@ -scalaVersion := "2.10.3" +import com.typesafe.tools.mima.plugin.{MimaPlugin, MimaKeys} + +scalaModuleSettings + +scalaVersion := "2.10.4" + +snapshotScalaBinaryVersion := "2.10.4" + +// TODO this project can be cross build against 2.11 and 2.10, express that here. organization := "org.scala-lang.modules" name := "scala-compat-jdk8" +// important!! must come here (why?) +scalaModuleOsgiSettings + +OsgiKeys.exportPackage := Seq(s"scala.compat.jdk8.*;version=${version.value}") + +libraryDependencies += "junit" % "junit" % "4.11" % "test" + +libraryDependencies += "com.novocode" % "junit-interface" % "0.10" % "test" + +MimaPlugin.mimaDefaultSettings + +MimaKeys.previousArtifact := None + +// run mima during tests +test in Test := { + MimaKeys.reportBinaryIssues.value + (test in Test).value +} + sourceGenerators in Compile <+= sourceManaged in Compile map { dir => def write(name: String, content: String) = { val f = dir / "java" / "scala" / "compat" / "jdk8" / s"${name}.java" @@ -21,3 +48,10 @@ sourceGenerators in Test <+= sourceManaged in Test map { dir => } Seq(write("TestApi", CodeGen.testApi)) } + +initialize := { + val _ = initialize.value + val specVersion = sys.props("java.specification.version") + if (Set("1.5", "1.6", "1.7") contains specVersion) + sys.error("Java 8 or higher is required for this project.") +} diff --git a/project/plugins.sbt b/project/plugins.sbt new file mode 100644 index 0000000..5f604e6 --- /dev/null +++ b/project/plugins.sbt @@ -0,0 +1,3 @@ +addSbtPlugin("org.scala-lang.modules" % "scala-module-plugin" % "1.0.2") + +addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.6") diff --git a/src/test/java/scala/compat/jdk8/LambdaTest.java b/src/test/java/scala/compat/jdk8/LambdaTest.java index f19a24e..d79e520 100644 --- a/src/test/java/scala/compat/jdk8/LambdaTest.java +++ b/src/test/java/scala/compat/jdk8/LambdaTest.java @@ -6,9 +6,11 @@ import scala.runtime.*; import static scala.compat.jdk8.TestAPI.*; import static scala.compat.jdk8.JFunction.*; +import org.junit.Test; public class LambdaTest { - public static void main(String[] args) { + @Test + public static void lambdaDemo() { // Not allowed with Scala 2.10 nor 2.11 // "incompatible types: Function1 is not a functional interface" // scala.Function1 f = (String s) -> s; From a59983e5b6dfca1b76fb0f92f45663926ad5c45b Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 13:43:41 +0100 Subject: [PATCH 5/7] Use relative links in README --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 1c6b91c..5712916 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ class Test { } ``` -[More Examples / Documentation](https://github.com/scala/scala-compat-jdk8/blob/master/src/test/java/scala/compat/jdk8/LambdaTest.java) +[More Examples / Documentation](src/test/java/scala/compat/jdk8/LambdaTest.java) ### Converters between `s.u.concurrent` and `j.u.concurrent` @@ -35,7 +35,7 @@ TODO ### Hacking -[Code Generator](https://github.com/scala/scala-compat-jdk8/blob/master/project/CodeGen.scala) +[Code Generator](project/CodeGen.scala) #### Running Examples From 1e9ce89d481c8f0d1f26d25a00577975ec11c344 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 16:20:41 +0100 Subject: [PATCH 6/7] s/jdk8/java8 s/scala-compat-jdk8/scala-java8-compat/ Are we there yet? --- README.md | 4 ++-- build.sbt | 8 ++++---- project/CodeGen.scala | 2 +- .../java/scala/compat/{jdk8 => java8}/LambdaTest.java | 6 +++--- 4 files changed, 10 insertions(+), 10 deletions(-) rename src/test/java/scala/compat/{jdk8 => java8}/LambdaTest.java (97%) diff --git a/README.md b/README.md index 5712916..6819d57 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ using Java 8 lambda syntax. ```java import scala.concurrent.*; -import static scala.compat.jdk8.JFunc.*; +import static scala.compat.java8.JFunction.*; class Test { private static Future futureExample(Future future, ExecutionContext ec) { @@ -19,7 +19,7 @@ class Test { } ``` -[More Examples / Documentation](src/test/java/scala/compat/jdk8/LambdaTest.java) +[More Examples / Documentation](src/test/java/scala/compat/java8/LambdaTest.java) ### Converters between `s.u.concurrent` and `j.u.concurrent` diff --git a/build.sbt b/build.sbt index 3f767ab..572b14e 100644 --- a/build.sbt +++ b/build.sbt @@ -10,12 +10,12 @@ snapshotScalaBinaryVersion := "2.10.4" organization := "org.scala-lang.modules" -name := "scala-compat-jdk8" +name := "scala-java8-compat" // important!! must come here (why?) scalaModuleOsgiSettings -OsgiKeys.exportPackage := Seq(s"scala.compat.jdk8.*;version=${version.value}") +OsgiKeys.exportPackage := Seq(s"scala.compat.java8.*;version=${version.value}") libraryDependencies += "junit" % "junit" % "4.11" % "test" @@ -33,7 +33,7 @@ test in Test := { sourceGenerators in Compile <+= sourceManaged in Compile map { dir => def write(name: String, content: String) = { - val f = dir / "java" / "scala" / "compat" / "jdk8" / s"${name}.java" + val f = dir / "java" / "scala" / "compat" / "java8" / s"${name}.java" IO.write(f, content) f } @@ -42,7 +42,7 @@ sourceGenerators in Compile <+= sourceManaged in Compile map { dir => sourceGenerators in Test <+= sourceManaged in Test map { dir => def write(name: String, content: String) = { - val f = dir / "java" / "scala" / "compat" / "jdk8" / s"${name}.java" + val f = dir / "java" / "scala" / "compat" / "java8" / s"${name}.java" IO.write(f, content) f } diff --git a/project/CodeGen.scala b/project/CodeGen.scala index 1d55c4c..662b9e6 100644 --- a/project/CodeGen.scala +++ b/project/CodeGen.scala @@ -17,7 +17,7 @@ object Type { } object CodeGen { - def packaging = "package scala.compat.jdk8;" + def packaging = "package scala.compat.java8;" case class arity(n: Int) { val ns = (1 to n).toList diff --git a/src/test/java/scala/compat/jdk8/LambdaTest.java b/src/test/java/scala/compat/java8/LambdaTest.java similarity index 97% rename from src/test/java/scala/compat/jdk8/LambdaTest.java rename to src/test/java/scala/compat/java8/LambdaTest.java index d79e520..33f3383 100644 --- a/src/test/java/scala/compat/jdk8/LambdaTest.java +++ b/src/test/java/scala/compat/java8/LambdaTest.java @@ -1,11 +1,11 @@ /* * Copyright (C) 2012-2014 Typesafe Inc. */ -package scala.compat.jdk8; +package scala.compat.java8; import scala.runtime.*; -import static scala.compat.jdk8.TestAPI.*; -import static scala.compat.jdk8.JFunction.*; +import static scala.compat.java8.TestAPI.*; +import static scala.compat.java8.JFunction.*; import org.junit.Test; public class LambdaTest { From 74fc9eeeda9d931e1404300c62c1ec67bcf0d767 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 24 Mar 2014 16:24:33 +0100 Subject: [PATCH 7/7] Simplify and document setting of the `intialize` build key --- build.sbt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/build.sbt b/build.sbt index 572b14e..c2c0f7a 100644 --- a/build.sbt +++ b/build.sbt @@ -50,7 +50,9 @@ sourceGenerators in Test <+= sourceManaged in Test map { dir => } initialize := { - val _ = initialize.value + // Run previously configured inialization... + initialize.value + // ... and then check the Java version. val specVersion = sys.props("java.specification.version") if (Set("1.5", "1.6", "1.7") contains specVersion) sys.error("Java 8 or higher is required for this project.")