mirror of https://github.com/sbt/sbt.git
* Removed build scripts and manual dependencies
* useDefaultConfigurations supersedes useMavenConfigurations and is now true by default * Moved installer-plugin to its own independent project as an sbt plugin * bumped version for 0.5 release * Updated project excludes for plugins * Specifying the explicit URL for dependency now infers the extension and type from the URL * Can load credentials from a properties file instead of adding them inline * Added help for '+' * Added method configurationPath to get the path to the directory containing dependencies downloaded for a Configuration * managedStyle = ManagedStyle.Maven by default now git-svn-id: https://simple-build-tool.googlecode.com/svn/trunk@813 d89573ee-9141-11dd-94d4-bdf5e562f29c
This commit is contained in:
dmharrah
commit
7f92cc5f4c
|
|
@ -0,0 +1,25 @@
|
|||
Copyright (c) 2008, 2009 Steven Blundy, Mark Harrah, David MacIver, Mikko Peltonen
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. 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.
|
||||
3. The name of the author may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
||||
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
Simple Build Tool (sbt)
|
||||
Copyright 2008, 2009 Steven Blundy, Mark Harrah, David MacIver, Mikko Peltonen
|
||||
|
||||
|
||||
Portions based on code by Pete Kirkham in Nailgun
|
||||
Copyright 2004, Martian Software, Inc
|
||||
Licensed under the Apache License, Version 2.0
|
||||
(see licenses/LICENSE_Apache)
|
||||
|
||||
Portions based on code from the Scala compiler
|
||||
Copyright 2002-2008 EPFL, Lausanne
|
||||
Licensed under BSD-style license (see licenses/LICENSE_Scala)
|
||||
|
||||
Portions based on code from specs
|
||||
Copyright (c) 2007-2008 Eric Torreborre
|
||||
Licensed under MIT license (see licenses/LICENSE_specs)
|
||||
|
||||
The following test frameworks are distributed with sbt (in
|
||||
the subversion repository):
|
||||
specs (see licenses/LICENSE_specs)
|
||||
ScalaCheck (see licenses/LICENSE_ScalaCheck)
|
||||
ScalaTest (see licenses/LICENSE_Apache)
|
||||
|
||||
Jetty is distributed with sbt (in the subversion repository) and is
|
||||
licensed under the Apache License, Version 2.0 (see
|
||||
licenses/LICENSE_Apache).
|
||||
|
||||
ScalaTest is distributed with sbt (in the subversion repository)
|
||||
and requires the following notice:
|
||||
|
||||
This product includes software developed by
|
||||
Artima, Inc. (http://www.artima.com/).
|
||||
|
||||
|
||||
Apache Ivy, licensed under the Apache License, Version 2.0
|
||||
(see licenses/LICENSE_Apache) is distributed with sbt and
|
||||
requires the following notice:
|
||||
|
||||
This product includes software developed by
|
||||
The Apache Software Foundation (http://www.apache.org/).
|
||||
|
||||
Portions of Ivy were originally developed by
|
||||
Jayasoft SARL (http://www.jayasoft.fr/)
|
||||
and are licensed to the Apache Software Foundation under the
|
||||
"Software Grant License Agreement"
|
||||
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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.
|
||||
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
Copyright (c) 2009 Mark Harrah
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. 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.
|
||||
3. The name of the author may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
||||
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
Simple Build Tool (sbt)
|
||||
Copyright 2009 Mark Harrah
|
||||
|
||||
Parts of the Scala library are distributed with sbt:
|
||||
Copyright 2002-2008 EPFL, Lausanne
|
||||
Licensed under BSD-style license (see licenses/LICENSE_Scala)
|
||||
|
||||
JLine is distributed with sbt:
|
||||
Copyright (c) 2002-2006, Marc Prud'hommeaux <mwp1@cornell.edu>
|
||||
Licensed under BSD-style license (see licenses/LICENSE_JLine)
|
||||
|
||||
Apache Ivy, licensed under the Apache License, Version 2.0
|
||||
(see licenses/LICENSE_Apache) is distributed with sbt and
|
||||
requires the following notice:
|
||||
|
||||
This product includes software developed by
|
||||
The Apache Software Foundation (http://www.apache.org/).
|
||||
|
||||
Portions of Ivy were originally developed by
|
||||
Jayasoft SARL (http://www.jayasoft.fr/)
|
||||
and are licensed to the Apache Software Foundation under the
|
||||
"Software Grant License Agreement"
|
||||
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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.
|
||||
|
||||
Binary file not shown.
|
|
@ -0,0 +1,258 @@
|
|||
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.
|
||||
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
License for JCraft JSch package
|
||||
------------------------------------------------------------------------------
|
||||
Copyright (c) 2002,2003,2004,2005,2006,2007 Atsuhiko Yamanaka, JCraft,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:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. 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.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE 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.
|
||||
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
License for jQuery
|
||||
------------------------------------------------------------------------------
|
||||
Copyright (c) 2007 John Resig, http://jquery.com/
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
Copyright (c) 2002-2006, Marc Prud'hommeaux <mwp1@cornell.edu>
|
||||
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 JLine 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.
|
||||
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
SCALA LICENSE
|
||||
|
||||
Copyright (c) 2002-2008 EPFL, Lausanne, unless otherwise specified.
|
||||
All rights reserved.
|
||||
|
||||
This software was developed by the Programming Methods Laboratory of the
|
||||
Swiss Federal Institute of Technology (EPFL), Lausanne, Switzerland.
|
||||
|
||||
Permission to use, copy, modify, and distribute this software in source
|
||||
or binary form for any purpose with or without fee is hereby granted,
|
||||
provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. 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.
|
||||
|
||||
3. 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 REGENTS 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 REGENTS 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.
|
||||
|
|
@ -0,0 +1,310 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.boot
|
||||
|
||||
// This is the main class for the sbt launcher. Its purpose is to ensure the appropriate
|
||||
// versions of sbt and scala are downloaded to the projects 'project/boot' directory.
|
||||
// Then, the downloaded version of sbt is started as usual using the right version of
|
||||
// scala.
|
||||
|
||||
// Artifact names must be consistent between the main sbt build and this build.
|
||||
|
||||
import java.io.{File, FileFilter}
|
||||
import java.net.{MalformedURLException, URL, URLClassLoader}
|
||||
|
||||
// contains constants and paths
|
||||
import BootConfiguration._
|
||||
import UpdateTarget.{UpdateScala, UpdateSbt}
|
||||
|
||||
// The exception to use when an error occurs at the launcher level (and not a nested exception).
|
||||
// This indicates overrides toString because the exception class name is not needed to understand
|
||||
// the error message.
|
||||
private class BootException(override val toString: String) extends RuntimeException
|
||||
// The entry point to the launcher
|
||||
object Boot
|
||||
{
|
||||
def main(args: Array[String])
|
||||
{
|
||||
System.setProperty("sbt.boot", true.toString)
|
||||
checkProxy()
|
||||
try { boot(args) }
|
||||
catch
|
||||
{
|
||||
case b: BootException => errorAndExit(b)
|
||||
case e =>
|
||||
e.printStackTrace
|
||||
errorAndExit(e)
|
||||
}
|
||||
System.exit(0)
|
||||
}
|
||||
private def errorAndExit(e: Throwable)
|
||||
{
|
||||
System.out.println("Error during sbt execution: " + e.toString)
|
||||
System.exit(1)
|
||||
}
|
||||
def boot(args: Array[String])
|
||||
{
|
||||
// prompt to create project if it doesn't exist.
|
||||
// will not return if user declines
|
||||
(new Paths).checkProject()
|
||||
val loaderCache = new LoaderCache
|
||||
if(args.length == 0)
|
||||
load(args, loaderCache) // interactive mode, which can only use one version of scala for a run
|
||||
else
|
||||
runBatch(args.toList, Nil, loaderCache) // batch mode, which can reboot with a different scala version
|
||||
}
|
||||
private def runBatch(args: List[String], accumulateReversed: List[String], loaderCache: LoaderCache)
|
||||
{
|
||||
def doLoad() = if(!accumulateReversed.isEmpty) load(accumulateReversed.reverse.toArray, loaderCache)
|
||||
args match
|
||||
{
|
||||
case Nil => doLoad()
|
||||
case RebootCommand :: tail =>
|
||||
doLoad()
|
||||
runBatch(tail, Nil, loaderCache)
|
||||
case action :: tail if action.trim.startsWith(CrossBuildPrefix) =>
|
||||
doLoad()
|
||||
load(Array(action), loaderCache) // call main with the single cross-build argument, preserving the '+' prefix, with which it knows what to do
|
||||
runBatch(tail, Nil, loaderCache)
|
||||
case notReload :: tail => runBatch(tail, notReload :: accumulateReversed, loaderCache)
|
||||
}
|
||||
}
|
||||
/** Loads the project in the current working directory using the version of scala and sbt
|
||||
* declared in the build. The class loader used prevents the Scala and Ivy classes used by
|
||||
* this loader from being seen by the loaded sbt/project.*/
|
||||
private def load(args: Array[String], loaderCache: LoaderCache)
|
||||
{
|
||||
val loader = (new Setup(loaderCache)).loader()
|
||||
val sbtMain = Class.forName(SbtMainClass, true, loader)
|
||||
val exitCode = run(sbtMain, args)
|
||||
if(exitCode == NormalExitCode)
|
||||
()
|
||||
else if(exitCode == RebootExitCode)
|
||||
load(args, loaderCache)
|
||||
else
|
||||
System.exit(exitCode)
|
||||
}
|
||||
private def run(sbtMain: Class[_], args: Array[String]): Int =
|
||||
{
|
||||
try {
|
||||
// Versions newer than 0.3.8 enter through the run method, which does not call System.exit
|
||||
val runMethod = sbtMain.getMethod(MainMethodName, classOf[Array[String]])
|
||||
runMethod.invoke(null, Array(args) : _*).asInstanceOf[Int]
|
||||
} catch {
|
||||
case e: NoSuchMethodException => runOld(sbtMain, args)
|
||||
}
|
||||
}
|
||||
/** The entry point for version 0.3.8 was the main method. */
|
||||
private def runOld(sbtMain: Class[_], args: Array[String]): Int =
|
||||
{
|
||||
val runMethod = sbtMain.getMethod(OldMainMethodName, classOf[Array[String]])
|
||||
runMethod.invoke(null, Array(args) : _*)
|
||||
NormalExitCode
|
||||
}
|
||||
|
||||
private def checkProxy()
|
||||
{
|
||||
import ProxyProperties._
|
||||
val httpProxy = System.getenv(HttpProxyEnv)
|
||||
if(isDefined(httpProxy) && !isPropertyDefined(ProxyHost) && !isPropertyDefined(ProxyPort))
|
||||
{
|
||||
try
|
||||
{
|
||||
val proxy = new URL(httpProxy)
|
||||
setProperty(ProxyHost, proxy.getHost)
|
||||
val port = proxy.getPort
|
||||
if(port >= 0)
|
||||
System.setProperty(ProxyPort, port.toString)
|
||||
copyEnv(HttpProxyUser, ProxyUser)
|
||||
copyEnv(HttpProxyPassword, ProxyPassword)
|
||||
}
|
||||
catch
|
||||
{
|
||||
case e: MalformedURLException =>
|
||||
System.out.println("Warning: could not parse http_proxy setting: " + e.toString)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def copyEnv(envKey: String, sysKey: String) { setProperty(sysKey, System.getenv(envKey)) }
|
||||
private def setProperty(key: String, value: String) { if(value != null) System.setProperty(key, value) }
|
||||
private def isPropertyDefined(k: String) = isDefined(System.getProperty(k))
|
||||
private def isDefined(s: String) = s != null && !s.isEmpty
|
||||
}
|
||||
|
||||
private class Paths extends NotNull
|
||||
{
|
||||
protected final val ProjectDirectory = new File(ProjectDirectoryName)
|
||||
protected final val BootDirectory = new File(ProjectDirectory, BootDirectoryName)
|
||||
protected final val PropertiesFile = new File(ProjectDirectory, BuildPropertiesName)
|
||||
|
||||
final def checkProject()
|
||||
{
|
||||
if(!ProjectDirectory.exists)
|
||||
{
|
||||
val line = SimpleReader.readLine("Project does not exist, create new project? (y/N/s) : ")
|
||||
if(Setup.isYes(line))
|
||||
ProjectProperties(PropertiesFile, true)
|
||||
else if(Setup.isScratch(line))
|
||||
ProjectProperties.scratch(PropertiesFile)
|
||||
else
|
||||
System.exit(1)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** A class to handle setting up the properties and classpath of the project
|
||||
* before it is loaded. */
|
||||
private class Setup(loaderCache: LoaderCache) extends Paths
|
||||
{
|
||||
/** Checks that the requested version of sbt and scala have been downloaded.
|
||||
* It performs a simple check that the appropriate directories exist. It uses Ivy
|
||||
* to resolve and retrieve any necessary libraries. The classpath to use is returned.*/
|
||||
final def loader(): ClassLoader = loader(Nil)
|
||||
private final def loader(forcePrompt: Seq[String]): ClassLoader =
|
||||
{
|
||||
val (normalScalaVersion, sbtVersion) = ProjectProperties.forcePrompt(PropertiesFile, forcePrompt : _*)
|
||||
val scalaVersion = crossScalaVersion(normalScalaVersion)
|
||||
loaderCache( scalaVersion, sbtVersion ) match
|
||||
{
|
||||
case Some(existingLoader) =>
|
||||
{
|
||||
setScalaVersion(scalaVersion)
|
||||
existingLoader
|
||||
}
|
||||
case None =>
|
||||
{
|
||||
getLoader(scalaVersion, sbtVersion) match
|
||||
{
|
||||
case Left(retry) => loader(retry)
|
||||
case Right(classLoader) => classLoader
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
private def crossScalaVersion(simpleScalaVersion: String): String =
|
||||
{
|
||||
val crossScalaVersion = System.getProperty(SbtScalaVersionKey)
|
||||
if(crossScalaVersion == null || crossScalaVersion.isEmpty)
|
||||
simpleScalaVersion
|
||||
else
|
||||
crossScalaVersion
|
||||
}
|
||||
private def getLoader(scalaVersion: String, sbtVersion: String): Either[Seq[String], ClassLoader] =
|
||||
{
|
||||
import Setup.{failIfMissing,isYes,needsUpdate}
|
||||
import ProjectProperties.{ScalaVersionKey, SbtVersionKey}
|
||||
|
||||
val baseDirectory = new File(BootDirectory, baseDirectoryName(scalaVersion))
|
||||
System.setProperty(ScalaHomeProperty, baseDirectory.getAbsolutePath)
|
||||
val scalaDirectory = new File(baseDirectory, ScalaDirectoryName)
|
||||
val sbtDirectory = new File(baseDirectory, sbtDirectoryName(sbtVersion))
|
||||
|
||||
val classLoader = createLoader(scalaDirectory, sbtDirectory)
|
||||
val updateTargets = needsUpdate("", classLoader, TestLoadScalaClasses, UpdateScala) ::: needsUpdate(sbtVersion, classLoader, TestLoadSbtClasses, UpdateSbt)
|
||||
if(updateTargets.isEmpty) // avoid loading Ivy related classes if there is nothing to update
|
||||
success(classLoader, scalaVersion, sbtVersion)
|
||||
else
|
||||
{
|
||||
Update(baseDirectory, sbtVersion, scalaVersion, updateTargets: _*)
|
||||
|
||||
val classLoader = createLoader(scalaDirectory, sbtDirectory)
|
||||
val sbtFailed = failIfMissing(classLoader, TestLoadSbtClasses, "sbt " + sbtVersion, SbtVersionKey)
|
||||
val scalaFailed = failIfMissing(classLoader, TestLoadScalaClasses, "Scala " + scalaVersion, ScalaVersionKey)
|
||||
|
||||
(scalaFailed +++ sbtFailed) match
|
||||
{
|
||||
case Success => success(classLoader, scalaVersion, sbtVersion)
|
||||
case f: Failure =>
|
||||
val noRetrieveMessage = "Could not retrieve " + f.label + "."
|
||||
val getNewVersions = SimpleReader.readLine(noRetrieveMessage + " Select different version? (y/N) : ")
|
||||
if(isYes(getNewVersions))
|
||||
Left(f.keys)
|
||||
else
|
||||
throw new BootException(noRetrieveMessage)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def success(classLoader: ClassLoader, scalaVersion: String, sbtVersion: String) =
|
||||
{
|
||||
setScalaVersion(scalaVersion)
|
||||
loaderCache( scalaVersion, sbtVersion ) = classLoader
|
||||
Right(classLoader)
|
||||
}
|
||||
private def createLoader(dirs: File*) =
|
||||
{
|
||||
val classpath = Setup.getJars(dirs : _*)
|
||||
new URLClassLoader(classpath.toArray, new BootFilteredLoader)
|
||||
}
|
||||
private def setScalaVersion(scalaVersion: String) { System.setProperty(SbtScalaVersionKey, scalaVersion) }
|
||||
}
|
||||
private final class LoaderCache
|
||||
{
|
||||
private[this] var cachedSbtVersion: Option[String] = None
|
||||
private[this] val loaderMap = new scala.collection.mutable.HashMap[String, ClassLoader]
|
||||
def apply(scalaVersion: String, sbtVersion: String): Option[ClassLoader] =
|
||||
{
|
||||
cachedSbtVersion flatMap { currentSbtVersion =>
|
||||
if(sbtVersion == currentSbtVersion)
|
||||
loaderMap.get(scalaVersion)
|
||||
else
|
||||
None
|
||||
}
|
||||
}
|
||||
def update(scalaVersion: String, sbtVersion: String, loader: ClassLoader)
|
||||
{
|
||||
for(currentSbtVersion <- cachedSbtVersion)
|
||||
{
|
||||
if(sbtVersion != currentSbtVersion)
|
||||
loaderMap.clear()
|
||||
}
|
||||
cachedSbtVersion = Some(sbtVersion)
|
||||
loaderMap(scalaVersion) = loader
|
||||
}
|
||||
}
|
||||
private object Setup
|
||||
{
|
||||
private def failIfMissing(loader: ClassLoader, classes: Iterable[String], label: String, key: String) = checkTarget(loader, classes, Success, new Failure(label, List(key)))
|
||||
private def needsUpdate(version: String, loader: ClassLoader, classes: Iterable[String], target: UpdateTarget.Value) =
|
||||
if(version.endsWith("-SNAPSHOT"))
|
||||
target :: Nil
|
||||
else
|
||||
checkTarget(loader, classes, Nil, target :: Nil)
|
||||
private def checkTarget[T](loader: ClassLoader, classes: Iterable[String], ifSuccess: => T, ifFailure: => T): T =
|
||||
{
|
||||
try
|
||||
{
|
||||
for(c <- classes)
|
||||
Class.forName(c, false, loader)
|
||||
ifSuccess
|
||||
}
|
||||
catch { case e: ClassNotFoundException => ifFailure }
|
||||
}
|
||||
def isYes(so: Option[String]) = isValue("y", "yes")(so)
|
||||
def isScratch(so: Option[String]) = isValue("s", "scratch")(so)
|
||||
def isValue(values: String*)(so: Option[String]) =
|
||||
so match
|
||||
{
|
||||
case Some(s) => values.contains(s.toLowerCase)
|
||||
case None => false
|
||||
}
|
||||
private def getJars(directories: File*) = directories.flatMap(file => wrapNull(file.listFiles(JarFilter))).map(_.toURI.toURL)
|
||||
private def wrapNull(a: Array[File]): Array[File] = if(a == null) Array() else a
|
||||
}
|
||||
|
||||
|
||||
private object JarFilter extends FileFilter
|
||||
{
|
||||
def accept(file: File) = !file.isDirectory && file.getName.endsWith(".jar")
|
||||
}
|
||||
|
||||
private sealed trait Checked extends NotNull { def +++(o: Checked): Checked }
|
||||
private final object Success extends Checked { def +++(o: Checked) = o }
|
||||
private final class Failure(val label: String, val keys: List[String]) extends Checked
|
||||
{
|
||||
def +++(o: Checked) =
|
||||
o match
|
||||
{
|
||||
case Success => this
|
||||
case f: Failure => new Failure(label + " and " + f.label, keys ::: f.keys)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.boot
|
||||
|
||||
// project/boot/ [BootDirectoryName]
|
||||
// scala-<version>/ [baseDirectoryName]
|
||||
// lib/ [ScalaDirectoryName]
|
||||
// sbt-<version>/ [sbtDirectoryName]
|
||||
//
|
||||
// see also ProjectProperties for the set of constants that apply to the build.properties file in a project
|
||||
private object BootConfiguration
|
||||
{
|
||||
val SbtMainClass = "sbt.Main"
|
||||
val MainMethodName = "run"
|
||||
val OldMainMethodName = "main"
|
||||
|
||||
// these are the module identifiers to resolve/retrieve
|
||||
val ScalaOrg = "org.scala-lang"
|
||||
val SbtOrg = "sbt"
|
||||
val CompilerModuleName = "scala-compiler"
|
||||
val LibraryModuleName = "scala-library"
|
||||
val SbtModuleName = "simple-build-tool"
|
||||
|
||||
/** The Ivy conflict manager to use for updating.*/
|
||||
val ConflictManagerName = "strict"
|
||||
/** The name of the local Ivy repository, which is used when compiling sbt from source.*/
|
||||
val LocalIvyName = "local"
|
||||
/** The pattern used for the local Ivy repository, which is used when compiling sbt from source.*/
|
||||
val LocalPattern = "[organisation]/[module]/[revision]/[type]s/[artifact].[ext]"
|
||||
/** The artifact pattern used for the local Ivy repository.*/
|
||||
def LocalArtifactPattern = LocalPattern
|
||||
/** The Ivy pattern used for the local Ivy repository.*/
|
||||
def LocalIvyPattern = LocalPattern
|
||||
|
||||
/** The name of the property declaring the version of scala to use to build the project when not cross-building.*/
|
||||
val ScalaVersion = "scala.version"
|
||||
/** The name of the property declaring the version of sbt to use to build the project.*/
|
||||
val SbtVersion = "sbt.version"
|
||||
/** The name of the system property containing the version of scala actually used to build a project.
|
||||
* This might be different from the ScalaVersion property when cross-building.*/
|
||||
val SbtScalaVersionKey = "sbt.scala.version"
|
||||
/** The class name prefix used to hide the Scala classes used by this loader from sbt
|
||||
* and the project definition*/
|
||||
val ScalaPackage = "scala."
|
||||
/** The class name prefix used to hide the Ivy classes used by this loader from sbt
|
||||
* and the project definition*/
|
||||
val IvyPackage = "org.apache.ivy."
|
||||
/** The loader will check that these classes can be loaded and will assume that their presence indicates
|
||||
* sbt and its dependencies have been downloaded.*/
|
||||
val TestLoadSbtClasses = "sbt.Main" :: "org.apache.ivy.Ivy" :: Nil
|
||||
/** The loader will check that these classes can be loaded and will assume that their presence indicates
|
||||
* the Scala compiler and library have been downloaded.*/
|
||||
val TestLoadScalaClasses = "scala.ScalaObject" :: "scala.tools.nsc.GenericRunnerCommand" :: Nil
|
||||
|
||||
val ProjectDirectoryName = "project"
|
||||
val BootDirectoryName = "boot"
|
||||
val BuildPropertiesName ="build.properties"
|
||||
val ScalaHomeProperty = "scala.home"
|
||||
val UpdateLogName = "update.log"
|
||||
|
||||
val CrossBuildPrefix = "+"
|
||||
val RebootCommand = "reboot"
|
||||
val RebootExitCode = -1
|
||||
val NormalExitCode = 0
|
||||
val DefaultIvyConfiguration = "default"
|
||||
|
||||
/** The base URL to use to resolve sbt for download. */
|
||||
val sbtRootBase = "http://simple-build-tool.googlecode.com/svn/artifacts/"
|
||||
/** The name of the directory within the boot directory to retrieve scala to. */
|
||||
val ScalaDirectoryName = "lib"
|
||||
/** The Ivy pattern to use for retrieving the scala compiler and library. It is relative to the directory
|
||||
* containing all jars for the requested version of scala. */
|
||||
val scalaRetrievePattern = ScalaDirectoryName + "/[artifact].[ext]"
|
||||
|
||||
/** The Ivy pattern to use for retrieving sbt and its dependencies. It is relative to the directory
|
||||
* containing all jars for the requested version of scala. */
|
||||
def sbtRetrievePattern(sbtVersion: String) = sbtDirectoryName(sbtVersion) + "/[artifact]-[revision].[ext]"
|
||||
/** The Ivy pattern to use for resolving sbt and its dependencies from the Google code project.*/
|
||||
def sbtResolverPattern(scalaVersion: String) = sbtRootBase + "[revision]/[type]s/[artifact].[ext]"
|
||||
/** The name of the directory to retrieve sbt and its dependencies to.*/
|
||||
def sbtDirectoryName(sbtVersion: String) = SbtOrg + "-" + sbtVersion
|
||||
/** The name of the directory in the boot directory to put all jars for the given version of scala in.*/
|
||||
def baseDirectoryName(scalaVersion: String) = "scala-" + scalaVersion
|
||||
}
|
||||
private object ProxyProperties
|
||||
{
|
||||
val HttpProxyEnv = "http_proxy"
|
||||
val HttpProxyUser = "http_proxy_user"
|
||||
val HttpProxyPassword = "http_proxy_pass"
|
||||
|
||||
val ProxyHost = "http.proxyHost"
|
||||
val ProxyPort = "http.proxyPort"
|
||||
val ProxyUser = "http.proxyUser"
|
||||
val ProxyPassword = "http.proxyPassword"
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.boot
|
||||
|
||||
import BootConfiguration._
|
||||
|
||||
/** A custom class loader to ensure the main part of sbt doesn't load any Scala or
|
||||
* Ivy classes from the jar containing the loader. */
|
||||
private[boot] final class BootFilteredLoader extends ClassLoader with NotNull
|
||||
{
|
||||
@throws(classOf[ClassNotFoundException])
|
||||
override final def loadClass(className: String, resolve: Boolean): Class[_] =
|
||||
{
|
||||
if(className.startsWith(ScalaPackage) || className.startsWith(IvyPackage))
|
||||
throw new ClassNotFoundException(className)
|
||||
else
|
||||
super.loadClass(className, resolve)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.boot
|
||||
|
||||
/*
|
||||
Project does not exist, create new project? [y/N] y
|
||||
Name:
|
||||
Organization []:
|
||||
Version [1.0]:
|
||||
Scala version [2.7.5]:
|
||||
sbt version [0.5]:
|
||||
*/
|
||||
import java.io.File
|
||||
/** Constants related to reading/writing the build.properties file in a project.
|
||||
* See BootConfiguration for general constants used by the loader. */
|
||||
private object ProjectProperties
|
||||
{
|
||||
/** The properties key for storing the name of the project.*/
|
||||
val NameKey = "project.name"
|
||||
/** The properties key for storing the organization of the project.*/
|
||||
val OrganizationKey = "project.organization"
|
||||
/** The properties key for storing the version of the project.*/
|
||||
val VersionKey = "project.version"
|
||||
/** The properties key for storing the version of Scala used with the project.*/
|
||||
val ScalaVersionKey = "scala.version"
|
||||
/** The properties key for storing the version of sbt used to build the project.*/
|
||||
val SbtVersionKey = "sbt.version"
|
||||
/** The properties key to communicate to the main component of sbt that the project
|
||||
* should be initialized after being loaded, typically by creating a default directory structure.*/
|
||||
val InitializeProjectKey = "project.initialize"
|
||||
/** The properties key that configures the project to be flattened a bit for use by quick throwaway projects.*/
|
||||
val ScratchKey = "project.scratch"
|
||||
|
||||
/** The label used when prompting for the name of the user's project.*/
|
||||
val NameLabel = "Name"
|
||||
/** The label used when prompting for the organization of the user's project.*/
|
||||
val OrganizationLabel = "Organization"
|
||||
/** The label used when prompting for the version of the user's project.*/
|
||||
val VersionLabel = "Version"
|
||||
/** The label used when prompting for the version of Scala to use for the user's project.*/
|
||||
val ScalaVersionLabel = "Scala version"
|
||||
/** The label used when prompting for the version of sbt to use for the user's project.*/
|
||||
val SbtVersionLabel = "sbt version"
|
||||
|
||||
/** The default organization of the new user project when the user doesn't explicitly specify one when prompted.*/
|
||||
val DefaultOrganization = ""
|
||||
/** The default version of the new user project when the user doesn't explicitly specify a version when prompted.*/
|
||||
val DefaultVersion = "1.0"
|
||||
/** The default version of sbt when the user doesn't explicitly specify a version when prompted.*/
|
||||
val DefaultSbtVersion = "0.5"
|
||||
/** The default version of Scala when the user doesn't explicitly specify a version when prompted.*/
|
||||
val DefaultScalaVersion = "2.7.5"
|
||||
|
||||
// sets up the project properties for a throwaway project (flattens src and lib to the root project directory)
|
||||
def scratch(file: File)
|
||||
{
|
||||
withProperties(file) { properties =>
|
||||
for( (key, _, default, _) <- propertyDefinitions(false))
|
||||
properties(key) = default.getOrElse("scratch")
|
||||
properties(ScratchKey) = true.toString
|
||||
}
|
||||
}
|
||||
// returns (scala version, sbt version)
|
||||
def apply(file: File, setInitializeProject: Boolean): (String, String) = applyImpl(file, setInitializeProject, Nil)
|
||||
def forcePrompt(file: File, propertyKeys: String*) = applyImpl(file, false, propertyKeys)
|
||||
private def applyImpl(file: File, setInitializeProject: Boolean, propertyKeys: Iterable[String]): (String, String) =
|
||||
{
|
||||
val organizationOptional = file.exists
|
||||
withProperties(file) { properties =>
|
||||
properties -= propertyKeys
|
||||
|
||||
prompt(properties, organizationOptional)
|
||||
if(setInitializeProject)
|
||||
properties(InitializeProjectKey) = true.toString
|
||||
}
|
||||
}
|
||||
// (key, label, defaultValue, promptRequired)
|
||||
private def propertyDefinitions(organizationOptional: Boolean) =
|
||||
(NameKey, NameLabel, None, true) ::
|
||||
(OrganizationKey, OrganizationLabel, Some(DefaultOrganization), !organizationOptional) ::
|
||||
(VersionKey, VersionLabel, Some(DefaultVersion), true) ::
|
||||
(ScalaVersionKey, ScalaVersionLabel, Some(DefaultScalaVersion), true) ::
|
||||
(SbtVersionKey, SbtVersionLabel, Some(DefaultSbtVersion), true) ::
|
||||
Nil
|
||||
private def prompt(fill: ProjectProperties, organizationOptional: Boolean)
|
||||
{
|
||||
for( (key, label, default, promptRequired) <- propertyDefinitions(organizationOptional))
|
||||
{
|
||||
val value = fill(key)
|
||||
if(value == null && promptRequired)
|
||||
fill(key) = readLine(label, default)
|
||||
}
|
||||
}
|
||||
private def withProperties(file: File)(f: ProjectProperties => Unit) =
|
||||
{
|
||||
val properties = new ProjectProperties(file)
|
||||
f(properties)
|
||||
properties.save
|
||||
(properties(ScalaVersionKey), properties(SbtVersionKey))
|
||||
}
|
||||
private def readLine(label: String, default: Option[String]): String =
|
||||
{
|
||||
val prompt =
|
||||
default match
|
||||
{
|
||||
case Some(d) => "%s [%s]: ".format(label, d)
|
||||
case None => "%s: ".format(label)
|
||||
}
|
||||
SimpleReader.readLine(prompt) orElse default match
|
||||
{
|
||||
case Some(line) => line
|
||||
case None => throw new BootException("Project not loaded: " + label + " not specified.")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
import java.io.{FileInputStream, FileOutputStream}
|
||||
import java.util.Properties
|
||||
private class ProjectProperties(file: File) extends NotNull
|
||||
{
|
||||
private[this] var modified = false
|
||||
private[this] val properties = new Properties
|
||||
if(file.exists)
|
||||
{
|
||||
val in = new FileInputStream(file)
|
||||
try { properties.load(in) } finally { in.close() }
|
||||
}
|
||||
|
||||
def update(key: String, value: String)
|
||||
{
|
||||
modified = true
|
||||
properties.setProperty(key, value)
|
||||
}
|
||||
def apply(key: String) = properties.getProperty(key)
|
||||
def save()
|
||||
{
|
||||
if(modified)
|
||||
{
|
||||
file.getParentFile.mkdirs()
|
||||
val out = new FileOutputStream(file)
|
||||
try { properties.store(out, "Project Properties") } finally { out.close() }
|
||||
modified = false
|
||||
}
|
||||
}
|
||||
def -= (keys: Iterable[String]) { for(key <- keys) properties.remove(key) }
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.boot
|
||||
|
||||
import jline.ConsoleReader
|
||||
object SimpleReader extends NotNull
|
||||
{
|
||||
protected[this] val reader =
|
||||
{
|
||||
val cr = new ConsoleReader
|
||||
cr.setBellEnabled(false)
|
||||
cr
|
||||
}
|
||||
def readLine(prompt: String) =
|
||||
reader.readLine(prompt) match
|
||||
{
|
||||
case null => None
|
||||
case x =>
|
||||
val trimmed = x.trim
|
||||
if(trimmed.isEmpty)
|
||||
None
|
||||
else
|
||||
Some(trimmed)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,248 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.boot
|
||||
|
||||
import java.io.{File, FileWriter, PrintWriter, Writer}
|
||||
|
||||
import org.apache.ivy.{core, plugins, util}
|
||||
import core.LogOptions
|
||||
import core.cache.DefaultRepositoryCacheManager
|
||||
import core.event.EventManager
|
||||
import core.module.id.ModuleRevisionId
|
||||
import core.module.descriptor.{Configuration, DefaultDependencyDescriptor, DefaultModuleDescriptor, ModuleDescriptor}
|
||||
import core.report.ResolveReport
|
||||
import core.resolve.{ResolveEngine, ResolveOptions}
|
||||
import core.retrieve.{RetrieveEngine, RetrieveOptions}
|
||||
import core.sort.SortEngine
|
||||
import core.settings.IvySettings
|
||||
import plugins.resolver.{ChainResolver, FileSystemResolver, IBiblioResolver, URLResolver}
|
||||
import util.{DefaultMessageLogger, Message}
|
||||
|
||||
import BootConfiguration._
|
||||
|
||||
private[boot] object UpdateTarget extends Enumeration
|
||||
{
|
||||
val UpdateScala, UpdateSbt = Value
|
||||
}
|
||||
import UpdateTarget.{UpdateSbt, UpdateScala}
|
||||
|
||||
object Update
|
||||
{
|
||||
/** Use Ivy to resolve and retrieve the specified 'targets' for the given versions.*/
|
||||
def apply(bootDirectory: File, sbtVersion: String, scalaVersion: String, targets: UpdateTarget.Value*) =
|
||||
synchronized // synchronized because Ivy is not thread-safe
|
||||
{
|
||||
val up = new Update(bootDirectory, sbtVersion, scalaVersion, targets : _*)
|
||||
up.update()
|
||||
}
|
||||
}
|
||||
/** Ensures that the Scala and sbt jars exist for the given versions or else downloads them.*/
|
||||
private final class Update(bootDirectory: File, sbtVersion: String, scalaVersion: String, targets: UpdateTarget.Value*)
|
||||
{
|
||||
private def logFile = new File(bootDirectory, UpdateLogName)
|
||||
/** A Writer to use to write the full logging information to a file for debugging. **/
|
||||
lazy val logWriter =
|
||||
{
|
||||
bootDirectory.mkdirs
|
||||
new PrintWriter(new FileWriter(logFile))
|
||||
}
|
||||
|
||||
/** The main entry point of this class for use by the Update module. It runs Ivy */
|
||||
private def update()
|
||||
{
|
||||
Message.setDefaultLogger(new SbtIvyLogger(logWriter))
|
||||
try { targets.foreach(update) } // runs update on each module separately
|
||||
catch
|
||||
{
|
||||
case e: Exception =>
|
||||
e.printStackTrace(logWriter)
|
||||
log(e.toString)
|
||||
println(" (see " + logFile + " for complete log)")
|
||||
}
|
||||
finally { logWriter.close() }
|
||||
}
|
||||
/** Runs update for the specified target (updates either the scala or sbt jars for building the project) */
|
||||
private def update(target: UpdateTarget.Value)
|
||||
{
|
||||
import Configuration.Visibility.PUBLIC
|
||||
// the actual module id here is not that important
|
||||
val moduleID = new DefaultModuleDescriptor(createID(SbtOrg, "boot", "1.0"), "release", null, false)
|
||||
moduleID.setLastModified(System.currentTimeMillis)
|
||||
moduleID.addConfiguration(new Configuration(DefaultIvyConfiguration, PUBLIC, "", Array(), true, null))
|
||||
// add dependencies based on which target needs updating
|
||||
target match
|
||||
{
|
||||
case UpdateScala =>
|
||||
addDependency(moduleID, ScalaOrg, CompilerModuleName, scalaVersion, "default")
|
||||
addDependency(moduleID, ScalaOrg, LibraryModuleName, scalaVersion, "default")
|
||||
update(moduleID, target, false)
|
||||
case UpdateSbt =>
|
||||
addDependency(moduleID, SbtOrg, SbtModuleName, sbtVersion, scalaVersion)
|
||||
try { update(moduleID, target, false) }
|
||||
catch
|
||||
{
|
||||
// unfortunately, there is not a more specific exception thrown when a configuration does not exist,
|
||||
// so we always retry after cleaning the ivy file for this version of sbt on in case it is a newer version
|
||||
// of Scala than when this version of sbt was initially published
|
||||
case e: RuntimeException =>
|
||||
update(moduleID, target, true)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Runs the resolve and retrieve for the given moduleID, which has had its dependencies added already. */
|
||||
private def update(moduleID: DefaultModuleDescriptor, target: UpdateTarget.Value, cleanExisting: Boolean)
|
||||
{
|
||||
val eventManager = new EventManager
|
||||
val settings = new IvySettings
|
||||
addResolvers(settings, scalaVersion, target)
|
||||
settings.setDefaultConflictManager(settings.getConflictManager(ConflictManagerName))
|
||||
settings.setBaseDir(bootDirectory)
|
||||
if(cleanExisting)
|
||||
{
|
||||
val sbtID = createID(SbtOrg, SbtModuleName, sbtVersion)
|
||||
onDefaultRepositoryCacheManager(settings) { cache =>
|
||||
val ivyFile = cache.getIvyFileInCache(sbtID)
|
||||
ivyFile.delete()
|
||||
val original = new File(ivyFile.getParentFile, ivyFile.getName + ".original")
|
||||
original.delete()
|
||||
}
|
||||
}
|
||||
resolve(settings, eventManager, moduleID)
|
||||
retrieve(settings, eventManager, moduleID, target)
|
||||
}
|
||||
private def createID(organization: String, name: String, revision: String) =
|
||||
ModuleRevisionId.newInstance(organization, name, revision)
|
||||
/** Adds the given dependency to the default configuration of 'moduleID'. */
|
||||
private def addDependency(moduleID: DefaultModuleDescriptor, organization: String, name: String, revision: String, conf: String)
|
||||
{
|
||||
val dep = new DefaultDependencyDescriptor(moduleID, createID(organization, name, revision), false, false, true)
|
||||
dep.addDependencyConfiguration(DefaultIvyConfiguration, conf)
|
||||
moduleID.addDependency(dep)
|
||||
}
|
||||
private def resolve(settings: IvySettings, eventManager: EventManager, module: ModuleDescriptor)
|
||||
{
|
||||
val resolveOptions = new ResolveOptions
|
||||
// this reduces the substantial logging done by Ivy, including the progress dots when downloading artifacts
|
||||
resolveOptions.setLog(LogOptions.LOG_DOWNLOAD_ONLY)
|
||||
val resolveEngine = new ResolveEngine(settings, eventManager, new SortEngine(settings))
|
||||
val resolveReport = resolveEngine.resolve(module, resolveOptions)
|
||||
if(resolveReport.hasError)
|
||||
{
|
||||
logExceptions(resolveReport)
|
||||
println(Set(resolveReport.getAllProblemMessages.toArray: _*).mkString(System.getProperty("line.separator")))
|
||||
throw new BootException("Error retrieving required libraries")
|
||||
}
|
||||
}
|
||||
/** Exceptions are logged to the update log file. */
|
||||
private def logExceptions(report: ResolveReport)
|
||||
{
|
||||
for(unresolved <- report.getUnresolvedDependencies)
|
||||
{
|
||||
val problem = unresolved.getProblem
|
||||
if(problem != null)
|
||||
problem.printStackTrace(logWriter)
|
||||
}
|
||||
}
|
||||
/** Retrieves resolved dependencies using the given target to determine the location to retrieve to. */
|
||||
private def retrieve(settings: IvySettings, eventManager: EventManager, module: ModuleDescriptor, target: UpdateTarget.Value)
|
||||
{
|
||||
val retrieveOptions = new RetrieveOptions
|
||||
val retrieveEngine = new RetrieveEngine(settings, eventManager)
|
||||
val pattern =
|
||||
target match
|
||||
{
|
||||
// see BuildConfiguration
|
||||
case UpdateSbt => sbtRetrievePattern(sbtVersion)
|
||||
case UpdateScala => scalaRetrievePattern
|
||||
}
|
||||
retrieveEngine.retrieve(module.getModuleRevisionId, pattern, retrieveOptions);
|
||||
}
|
||||
/** Add the scala tools repositories and a URL resolver to download sbt from the Google code project.*/
|
||||
private def addResolvers(settings: IvySettings, scalaVersion: String, target: UpdateTarget.Value)
|
||||
{
|
||||
val newDefault = new ChainResolver
|
||||
newDefault.setName("redefined-public")
|
||||
newDefault.add(localResolver(settings.getDefaultIvyUserDir.getAbsolutePath))
|
||||
newDefault.add(mavenLocal)
|
||||
target match
|
||||
{
|
||||
case UpdateSbt =>
|
||||
newDefault.add(sbtResolver(scalaVersion))
|
||||
newDefault.add(mavenMainResolver)
|
||||
case UpdateScala =>
|
||||
newDefault.add(mavenResolver("Scala-Tools Maven2 Repository", "http://scala-tools.org/repo-releases"))
|
||||
newDefault.add(mavenResolver("Scala-Tools Maven2 Snapshots Repository", "http://scala-tools.org/repo-snapshots"))
|
||||
}
|
||||
onDefaultRepositoryCacheManager(settings)(_.setUseOrigin(true))
|
||||
settings.addResolver(newDefault)
|
||||
settings.setDefaultResolver(newDefault.getName)
|
||||
}
|
||||
private def onDefaultRepositoryCacheManager(settings: IvySettings)(f: DefaultRepositoryCacheManager => Unit)
|
||||
{
|
||||
settings.getDefaultRepositoryCacheManager match
|
||||
{
|
||||
case manager: DefaultRepositoryCacheManager => f(manager)
|
||||
case _ => ()
|
||||
}
|
||||
}
|
||||
/** Uses the pattern defined in BuildConfiguration to download sbt from Google code.*/
|
||||
private def sbtResolver(scalaVersion: String) =
|
||||
{
|
||||
val pattern = sbtResolverPattern(scalaVersion)
|
||||
val resolver = new URLResolver
|
||||
resolver.setName("Sbt Repository")
|
||||
resolver.addIvyPattern(pattern)
|
||||
resolver.addArtifactPattern(pattern)
|
||||
resolver
|
||||
}
|
||||
private def mavenLocal = mavenResolver("Maven2 Local", "file://" + System.getProperty("user.home") + "/.m2/repository/")
|
||||
/** Creates a maven-style resolver.*/
|
||||
private def mavenResolver(name: String, root: String) =
|
||||
{
|
||||
val resolver = defaultMavenResolver(name)
|
||||
resolver.setRoot(root)
|
||||
resolver
|
||||
}
|
||||
/** Creates a resolver for Maven Central.*/
|
||||
private def mavenMainResolver = defaultMavenResolver("Maven Central")
|
||||
/** Creates a maven-style resolver with the default root.*/
|
||||
private def defaultMavenResolver(name: String) =
|
||||
{
|
||||
val resolver = new IBiblioResolver
|
||||
resolver.setName(name)
|
||||
resolver.setM2compatible(true)
|
||||
resolver
|
||||
}
|
||||
private def localResolver(ivyUserDirectory: String) =
|
||||
{
|
||||
val localIvyRoot = ivyUserDirectory + "/local"
|
||||
val artifactPattern = localIvyRoot + "/" + LocalArtifactPattern
|
||||
val ivyPattern = localIvyRoot + "/" + LocalIvyPattern
|
||||
val resolver = new FileSystemResolver
|
||||
resolver.setName(LocalIvyName)
|
||||
resolver.addIvyPattern(ivyPattern)
|
||||
resolver.addArtifactPattern(artifactPattern)
|
||||
resolver
|
||||
}
|
||||
/** Logs the given message to a file and to the console. */
|
||||
private def log(msg: String) =
|
||||
{
|
||||
try { logWriter.println(msg) }
|
||||
catch { case e: Exception => System.err.println("Error writing to update log file: " + e.toString) }
|
||||
println(msg)
|
||||
}
|
||||
}
|
||||
/** A custom logger for Ivy to ignore the messages about not finding classes
|
||||
* intentionally filtered using proguard. */
|
||||
private final class SbtIvyLogger(logWriter: PrintWriter) extends DefaultMessageLogger(Message.MSG_INFO) with NotNull
|
||||
{
|
||||
private val ignorePrefix = "impossible to define"
|
||||
override def log(msg: String, level: Int)
|
||||
{
|
||||
logWriter.println(msg)
|
||||
if(level <= getLevel && msg != null && !msg.startsWith(ignorePrefix))
|
||||
System.out.println(msg)
|
||||
}
|
||||
override def rawlog(msg: String, level: Int) { log(msg, level) }
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.extract
|
||||
|
||||
import java.io.{File, InputStream}
|
||||
import java.util.zip.{ZipEntry, ZipFile}
|
||||
|
||||
object Main
|
||||
{
|
||||
lazy val log: Logger = new ConsoleLogger
|
||||
|
||||
def main(args: Array[String])
|
||||
{
|
||||
if(args.contains("debug"))
|
||||
log.setLevel(Level.Debug)
|
||||
val result = OpenResource.zipFile.ioOption(FileUtilities.classLocationFile[Install], "processing", log)(process)
|
||||
for(msg <- result)
|
||||
{
|
||||
log.error(msg)
|
||||
System.exit(1)
|
||||
}
|
||||
}
|
||||
private[this] val packedGzip = ".pack.gz"
|
||||
private def isArchive(name: String) = name.endsWith(".gz") || name.endsWith(".zip")
|
||||
private def process(zip: ZipFile) =
|
||||
{
|
||||
val installEntry = zip.getEntry("install")
|
||||
if(installEntry == null)
|
||||
Some("Install commands not found.")
|
||||
else
|
||||
{
|
||||
val jarAndZip = wrap.Wrappers.toList(zip.entries).filter(entry => isArchive(entry.getName)).partition(_.getName.endsWith(packedGzip))
|
||||
jarAndZip match
|
||||
{
|
||||
case (Nil, _)=> Some("sbt loader not found.")
|
||||
case (_, Nil) => Some("Project to extract and build not found.")
|
||||
case (loaderEntry :: _, projectEntry :: _) => extractAndRun(zip, loaderEntry, projectEntry, installEntry)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def extractAndRun(zip: ZipFile, loaderEntry: ZipEntry, projectEntry: ZipEntry, installEntry: ZipEntry) =
|
||||
{
|
||||
val zipResource = OpenResource.zipEntry(zip)
|
||||
|
||||
import FileUtilities.{gunzip, readString, transfer, unzip, writeStream}
|
||||
val directory = new File(".", trimExtension(projectEntry.getName, ".zip"))
|
||||
assume(!directory.exists, "Could not extract project: directory " + projectEntry.getName + " exists.")
|
||||
|
||||
val loaderBaseName = trimExtension(loaderEntry.getName, packedGzip)
|
||||
val loaderFile = new File(directory, loaderBaseName + ".jar")
|
||||
val tempLoaderFile = new File(directory, loaderBaseName + ".pack")
|
||||
|
||||
def extractLoader() =
|
||||
{
|
||||
implicit def fileToPath(f: File) = Path.fromFile(f)
|
||||
val result =
|
||||
writeStream(tempLoaderFile, log) { out => zipResource.ioOption(loaderEntry, "reading", log)(gunzip(_, out, log)) } orElse
|
||||
Pack.unpack(tempLoaderFile, loaderFile, log)
|
||||
FileUtilities.clean(tempLoaderFile :: Nil, true, log)
|
||||
result.toLeft(loaderFile)
|
||||
}
|
||||
|
||||
Control.thread(zipResource.io(installEntry, "reading", log)(readString(_, log))) { installString =>
|
||||
Control.thread(parseInstall(installString)) { install =>
|
||||
zipResource.io(projectEntry, "reading", log)(unzip(_, Path.fromFile(directory), log)).left.toOption orElse
|
||||
Control.thread(extractLoader()) { loaderFile =>
|
||||
run(loaderFile, directory, install)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
private def parseInstall(installString: String): Either[String, Install] =
|
||||
{
|
||||
installString.split(separator) match
|
||||
{
|
||||
case Array(allOptions, allActions) =>
|
||||
val options = allOptions.split("""\n""").toList
|
||||
val actions = allActions.split("""\n""").toList
|
||||
Right( Install(options, actions) )
|
||||
case _ => Left("Invalid install script (no separator found)")
|
||||
}
|
||||
}
|
||||
private def filterEmpty(list: List[String]) = list.filter(!_.isEmpty)
|
||||
private def run(loader: File, project: File, install: Install) =
|
||||
{
|
||||
val command = "java" :: "-cp" :: loader.getAbsolutePath :: filterEmpty(install.options) ::: "sbt.boot.Boot" :: filterEmpty(install.actions)
|
||||
val builder = new java.lang.ProcessBuilder(command.toArray : _*)
|
||||
builder.directory(project)
|
||||
//import BasicIO.{processFully, transferFully}
|
||||
//val standardIO = new ProcessIO(transferFully(System.in, _, 0), processFully(System.out.println), processFully(System.err.println))
|
||||
val exitCode = ( Process(builder) ! )//( Process(builder) run standardIO).exitValue()
|
||||
if(exitCode == 0)
|
||||
None
|
||||
else
|
||||
Some("sbt exited with nonzero exit code: " + exitCode)
|
||||
}
|
||||
private def trimExtension(name: String, ext: String) =
|
||||
{
|
||||
if(name.endsWith(ext))
|
||||
name.substring(0, name.length - ext.length)
|
||||
else
|
||||
name
|
||||
}
|
||||
// keep this in sync with sbt.extract.SelfExtractingProject
|
||||
private def separator = "===================="
|
||||
}
|
||||
private final case class Install(options: List[String], actions: List[String]) extends NotNull
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.extract
|
||||
|
||||
import java.io.{ByteArrayOutputStream, File}
|
||||
import FileUtilities.{classLocationFile, clean, createTemporaryDirectory, download, transferAndClose, unzip, write, zip}
|
||||
import SelfExtractingProject.{flat, separator}
|
||||
|
||||
trait SelfExtractingProject extends Project
|
||||
{
|
||||
protected def createSelfExtractingJar(actions: List[String], jvmOptions: List[String], projectZip: Path, outputJar: Path): Option[String] =
|
||||
{
|
||||
def jarForClass(name: String) = Path.fromFile(classLocationFile(Class.forName(name)))
|
||||
val loaderJar = jarForClass("sbt.boot.Boot")
|
||||
val bytes = new ByteArrayOutputStream
|
||||
transferAndClose(this.getClass.getResourceAsStream("extract.location"), bytes, log) orElse
|
||||
{
|
||||
val extractorJarLocation = bytes.toString("UTF-8")
|
||||
createSelfExtractingJar(actions, jvmOptions, projectZip, loaderJar, extractorJarLocation, outputJar)
|
||||
}
|
||||
}
|
||||
private def createSelfExtractingJar(actions: List[String], jvmOptions: List[String], projectZip: Path, loaderJar: Path, extractorJarLocation: String, outputJar: Path): Option[String] =
|
||||
{
|
||||
val installContents = jvmOptions.mkString("\n") + separator + actions.mkString("\n")
|
||||
withTemporaryDirectory(log) { tmp =>
|
||||
val tmpPath = Path.fromFile(tmp)
|
||||
write(new File(tmp, "install"), installContents, log) orElse
|
||||
unzip(this.getClass.getResource(extractorJarLocation), tmpPath, log).left.toOption orElse
|
||||
Control.thread(compressLoader(loaderJar)) { compressedLoader =>
|
||||
zip( (tmpPath ##) :: flat(projectZip) :: compressedLoader :: Nil, outputJar, true, log)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def withTemporaryDirectory(log: Logger)(f: File => Option[String]) =
|
||||
{
|
||||
Control.thread(createTemporaryDirectory(log)) { dir =>
|
||||
Control.trapUnitAndFinally("", log)
|
||||
{ f(dir) }
|
||||
{ clean(Path.fromFile(dir) :: Nil, true, log) }
|
||||
}
|
||||
}
|
||||
private def compressLoader(loaderJar: Path): Either[String, Path] =
|
||||
{
|
||||
val jarName = loaderJar.asFile.getName
|
||||
val dotIndex = jarName.lastIndexOf('.')
|
||||
val baseName =
|
||||
if(dotIndex > 0) jarName.substring(0, dotIndex)
|
||||
else jarName
|
||||
val packedName = baseName + ".pack"
|
||||
val packed = outputPath / packedName
|
||||
val packedAndGzip = (outputPath ##) / (packedName + ".gz")
|
||||
val result =
|
||||
Pack.pack(loaderJar, packed, log) orElse
|
||||
FileUtilities.gzip(packed, packedAndGzip, log)
|
||||
result.toLeft(packedAndGzip)
|
||||
}
|
||||
}
|
||||
trait BasicSelfExtractingProject extends BasicScalaProject with SelfExtractingProject
|
||||
{
|
||||
def installActions: List[String] = update.name :: `package`.name :: Nil
|
||||
def jvmOptions: List[String] = Nil
|
||||
def selfExtractingJar: Path = outputPath / (artifactBaseName + "-setup.jar")
|
||||
|
||||
lazy val installer = installerAction
|
||||
def installerAction = task { createSelfExtractingJar(installActions, jvmOptions, packageProjectZip, selfExtractingJar) } dependsOn packageProject
|
||||
}
|
||||
|
||||
object SelfExtractingProject
|
||||
{
|
||||
// keep this in sync with sbt.extract.Main.separator
|
||||
def separator = "===================="
|
||||
private def flat(p: Path) =
|
||||
p match
|
||||
{
|
||||
case rp: RelativePath => (rp.parentPath ##) / rp.component
|
||||
case _ => p
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
#Project properties
|
||||
#Thu Jun 25 14:31:30 EDT 2009
|
||||
project.organization=org.scala-tools.sbt
|
||||
project.name=extract
|
||||
sbt.version=0.4.7-p13
|
||||
project.version=0.1
|
||||
scala.version=2.7.5
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
import sbt._
|
||||
|
||||
import java.io.File
|
||||
import java.nio.charset.Charset
|
||||
|
||||
class InstallerProject(info: ProjectInfo) extends ParentProject(info)
|
||||
{
|
||||
lazy val installExtractor: InstallExtractProject = project("extract", "Installer Extractor", new InstallExtractProject(_, installPlugin))
|
||||
lazy val installPlugin: InstallPluginProject = project("plugin", "Installer Plugin", new InstallPluginProject(_, installExtractor), installExtractor)
|
||||
}
|
||||
protected class InstallPluginProject(info: ProjectInfo, extract: => InstallExtractProject) extends PluginProject(info)
|
||||
{
|
||||
private lazy val extractProject = extract
|
||||
override def crossScalaVersions = Set("2.7.2", "2.7.3", "2.7.4", "2.7.5")
|
||||
override def mainResources = super.mainResources +++ extractProject.outputJar +++ extractLocation
|
||||
|
||||
def extractLocation = (outputPath ##) / "extract.location"
|
||||
lazy val writeProperties = task { FileUtilities.write(extractLocation.asFile, extractProject.outputJar.relativePath, Charset.forName("UTF-8"), log) }
|
||||
override def packageAction = super.packageAction dependsOn(extractProject.proguard, writeProperties)
|
||||
|
||||
val publishTo = "Scala Tools Nexus" at "http://nexus.scala-tools.org/content/repositories/releases/"
|
||||
Credentials(Path.fromFile(System.getProperty("user.home")) / ".ivy2" / ".credentials", log)
|
||||
}
|
||||
protected class InstallExtractProject(info: ProjectInfo, pluginProject: => InstallPluginProject) extends DefaultProject(info)
|
||||
{
|
||||
override def publishLocalAction = publishAction
|
||||
override def publishAction = task {None}
|
||||
override def unmanagedClasspath = super.unmanagedClasspath +++ Path.lazyPathFinder(Path.fromFile(FileUtilities.sbtJar) :: Nil)
|
||||
private lazy val plugin = pluginProject
|
||||
val mainClassName = "sbt.extract.Main"
|
||||
val proguardConfigurationPath: Path = outputPath / "proguard.pro"
|
||||
val toolsConfig = config("tools")
|
||||
val defaultConfig = Configurations.Default
|
||||
val proguardJar = "net.sf.proguard" % "proguard" % "4.3" % "tools->default"
|
||||
def rootProjectDirectory = rootProject.info.projectPath
|
||||
def outputJar = (plugin.outputPath ##) / defaultJarName
|
||||
|
||||
/******** Proguard *******/
|
||||
lazy val proguard = proguardTask dependsOn(`package`, writeProguardConfiguration)
|
||||
lazy val writeProguardConfiguration = writeProguardConfigurationTask dependsOn `package`
|
||||
|
||||
private def proguardTask =
|
||||
task
|
||||
{
|
||||
FileUtilities.clean(outputJar :: Nil, log)
|
||||
val proguardClasspathString = Path.makeString(managedClasspath(toolsConfig).get)
|
||||
val configFile = proguardConfigurationPath.asFile.getAbsolutePath
|
||||
val exitValue = Process("java", List("-Xmx256M", "-cp", proguardClasspathString, "proguard.ProGuard", "@" + configFile)) ! log
|
||||
if(exitValue == 0) None else Some("Proguard failed with nonzero exit code (" + exitValue + ")")
|
||||
}
|
||||
private def writeProguardConfigurationTask =
|
||||
task
|
||||
{
|
||||
// the template for the proguard configuration file
|
||||
val outTemplate = """
|
||||
|-dontoptimize
|
||||
|-dontobfuscate
|
||||
|-dontnote
|
||||
|-dontwarn
|
||||
|-libraryjars %s
|
||||
|%s
|
||||
|-outjars %s
|
||||
|-ignorewarnings
|
||||
|-keep public class %s {
|
||||
| public static void main(java.lang.String[]);
|
||||
|}"""
|
||||
|
||||
val defaultJar = jarPath.absolutePath
|
||||
log.debug("proguard configuration using main jar " + defaultJar)
|
||||
val externalDependencies = (mainCompileConditional.analysis.allExternals).map(_.getAbsoluteFile).filter(_.getName.endsWith(".jar"))
|
||||
debugJars("external dependencies", externalDependencies)
|
||||
// partition jars from the external jar dependencies of this project by whether they are located in the project directory
|
||||
// if they are, they are specified with -injars, otherwise they are specified with -libraryjars
|
||||
val (externalJars, libraryJars) = externalDependencies.toList.partition{jar => Path.relativize(rootProjectDirectory, jar).isDefined}
|
||||
debugJars("library jars", libraryJars)
|
||||
val sbtJarString = FileUtilities.sbtJar.getAbsolutePath + "(!META-INF/**,!licenses/**,LICENSE,NOTICE,!*.xml)"
|
||||
val externalJarStrings = externalJars.map( _ + "(!META-INF/**,!*.properties)")
|
||||
// exclude properties files and manifests from scala-library jar
|
||||
val inJars = (defaultJar :: externalJarStrings).map("-injars " + _).mkString("\n")
|
||||
|
||||
val proguardConfiguration = outTemplate.stripMargin.format(libraryJars.mkString(File.pathSeparator), inJars, outputJar.absolutePath, mainClassName)
|
||||
log.debug("Proguard configuration written to " + proguardConfigurationPath)
|
||||
FileUtilities.write(proguardConfigurationPath.asFile, proguardConfiguration, log)
|
||||
}
|
||||
private def debugJars[T](label: String, jars: Iterable[T]): Unit =
|
||||
log.debug("proguard configuration " + label + ": \n\t" + jars.mkString("\n\t"))
|
||||
}
|
||||
|
|
@ -0,0 +1,176 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
SCALA LICENSE
|
||||
|
||||
Copyright (c) 2002-2008 EPFL, Lausanne, unless otherwise specified.
|
||||
All rights reserved.
|
||||
|
||||
This software was developed by the Programming Methods Laboratory of the
|
||||
Swiss Federal Institute of Technology (EPFL), Lausanne, Switzerland.
|
||||
|
||||
Permission to use, copy, modify, and distribute this software in source
|
||||
or binary form for any purpose with or without fee is hereby granted,
|
||||
provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. 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.
|
||||
|
||||
3. 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 REGENTS 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 REGENTS 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.
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
ScalaCheck LICENSE
|
||||
|
||||
Copyright (c) 2007, Rickard Nilsson
|
||||
All rights reserved.
|
||||
|
||||
Permission to use, copy, modify, and distribute this software in source
|
||||
or binary form for any purpose with or without fee is hereby granted,
|
||||
provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. 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.
|
||||
|
||||
3. Neither the name of the author 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 REGENTS 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 REGENTS 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.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
Copyright (c) 2008 Mark Harrah, David MacIver
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. 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.
|
||||
3. The name of the author may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
||||
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
Copyright (c) 2007-2008 Eric Torreborre
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
Neither the name of specs nor the names of its contributors may be
|
||||
used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
#Project properties
|
||||
#Thu Jun 25 20:59:30 EDT 2009
|
||||
project.organization=sbt
|
||||
project.name=Simple Build Tool Parent
|
||||
sbt.version=0.4.6
|
||||
project.version=0.5
|
||||
scala.version=2.7.2
|
||||
|
|
@ -0,0 +1,207 @@
|
|||
import sbt._
|
||||
|
||||
import java.io.File
|
||||
import scala.xml.NodeSeq
|
||||
|
||||
/** Support for compiling sbt across multiple versions of Scala. The scala compiler is run in a
|
||||
* separate JVM and no partial compilation is done.*/
|
||||
abstract class CrossCompileProject extends BasicScalaProject
|
||||
{
|
||||
/** Used for 2.8.0-SNAPSHOT*/
|
||||
val scalaToolsSnapshots = "Scala Tools Snapshots" at "http://scala-tools.org/repo-snapshots"
|
||||
|
||||
/* The base configuration names for the versions of Scala*/
|
||||
private val version2_7_2 = "2.7.2"
|
||||
private val version2_7_3 = "2.7.3"
|
||||
private val version2_7_4 = "2.7.4"
|
||||
private val version2_7_5 = "2.7.5"
|
||||
private val version2_8_0 = "2.8.0.r18093-b20090623200909"
|
||||
private val base = "base"
|
||||
|
||||
/* The configurations for the versions of Scala.*/
|
||||
private val conf_2_7_2 = config(version2_7_2)
|
||||
private val conf_2_7_3 = config(version2_7_3)
|
||||
private val conf_2_7_4 = config(version2_7_4)
|
||||
private val conf_2_7_5 = config(version2_7_5)
|
||||
private val conf_2_8_0 = config(version2_8_0)
|
||||
private val conf_base = config(base)
|
||||
// the list of all configurations cross-compile supports
|
||||
private val allConfigurations = conf_2_7_2 :: conf_2_7_3 :: conf_2_7_4 :: conf_2_7_5 :: conf_2_8_0 :: Nil
|
||||
// the list of configurations to actually build against
|
||||
private val buildConfigurations = conf_2_7_2 :: conf_2_7_3 :: conf_2_7_4 :: conf_2_7_5 :: Nil//allConfigurations not currently used because of issues with 2.8.0
|
||||
// the configuration to use for normal development (when cross-building is not done)
|
||||
private def developmentVersion = buildConfigurations.first
|
||||
|
||||
/* Methods to derive the configuration name from the base name 'v'.*/
|
||||
private def optional(v: Configuration) = config("optional-" + v.toString)
|
||||
private def scalac(v: Configuration) = config("scalac-" + v.toString)
|
||||
private def sbt(v: Configuration) = config("sbt_" + v.toString)
|
||||
private def depConf(v: Configuration) = v.toString + "->default"
|
||||
|
||||
// =========== Cross-compilation across scala versions ===========
|
||||
|
||||
// The dependencies that should go in each configuration are:
|
||||
// base Required dependencies that are the same across all scala versions.
|
||||
// <version> Required dependencies to use with Scala <version>
|
||||
// optional-base Optional dependencies that are the same for all scala versions
|
||||
// optional-<version> Optional dependencies to use with Scala <version>
|
||||
// compile Used for normal development, it should extend a specific <version> and optional-<version>
|
||||
// scalac-<version> The scala compiler for Scala <version>
|
||||
// There should be a jar publication for each version of scala. The artifact should be named sbt_<version>.
|
||||
override def ivyXML =
|
||||
(<configurations>
|
||||
<conf name={conf_base.toString}/>
|
||||
<conf name={optional(conf_base).toString}/>
|
||||
{ variableConfigurations }
|
||||
<!-- The configuration used for normal development (actions other than cross-*) -->
|
||||
<conf name="default" extends={developmentVersion + "," + optional(developmentVersion).toString} visibility="private"/>
|
||||
</configurations>
|
||||
<publications>
|
||||
{ publications }
|
||||
</publications>
|
||||
<dependencies>
|
||||
<!-- Dependencies that are the same across all Scala versions -->
|
||||
<dependency org="org.apache.ivy" name="ivy" rev="2.0.0" transitive="false" conf={depConf(conf_base)}/>
|
||||
<dependency org="com.jcraft" name="jsch" rev="0.1.31" transitive="false" conf={depConf(conf_base)}/>
|
||||
<dependency org="org.mortbay.jetty" name="jetty" rev="6.1.14" transitive="true" conf={depConf(optional(conf_base))}/>
|
||||
|
||||
<!-- the dependencies that are different dependeding on the version of Scala -->
|
||||
{ variableDependencies(conf_2_7_2, /*ScalaTest*/"0.9.3", /*Specs*/"1.4.0", false) }
|
||||
{ variableDependencies(conf_2_7_3, /*ScalaTest*/"0.9.4", /*Specs*/"1.4.3", true) }
|
||||
{ variableDependencies(conf_2_7_4, /*ScalaTest*/"0.9.5", /*Specs*/"1.4.3", true) }
|
||||
{ variableDependencies(conf_2_7_5, /*ScalaTest*/"0.9.5", /*Specs*/"1.4.3", true) }
|
||||
{ variableDependencies(conf_2_8_0, /*ScalaTest*/"0.9.5", /*Specs*/"1.4.3", true) }
|
||||
</dependencies>)
|
||||
|
||||
/** Creates a publication (an 'artifact' element) for each Scala version */
|
||||
private def publications: NodeSeq =
|
||||
{
|
||||
for(conf <- buildConfigurations) yield
|
||||
<artifact name={sbt(conf).toString} conf={conf.toString}/>
|
||||
}
|
||||
/** Creates the main, optional, and scalac configurations for each Scala version*/
|
||||
private def variableConfigurations: NodeSeq =
|
||||
{
|
||||
buildConfigurations flatMap
|
||||
{ conf =>
|
||||
scalaComment(conf) ++
|
||||
(<conf name={conf.toString} extends={conf_base.toString}/>
|
||||
<conf name={optional(conf).toString} extends={optional(conf_base).toString}/>
|
||||
<conf name={scalac(conf).toString} visibility="private"/>)
|
||||
}
|
||||
}
|
||||
/** Defines the dependencies for the given version of Scala, ScalaTest, and Specs. If uniformTestOrg is true,
|
||||
* the 'org.scala-tools.testing' organization is used. Otherwise, 'org.' is prefixed to the module name. */
|
||||
private def variableDependencies(scalaVersion: Configuration, scalaTestVersion: String, specsVersion: String, uniformTestOrg: Boolean) =
|
||||
{
|
||||
if(buildConfigurations.contains(scalaVersion))
|
||||
{
|
||||
scalaComment(scalaVersion) ++
|
||||
{
|
||||
if(scalaVersion eq conf_2_8_0)
|
||||
Nil
|
||||
else
|
||||
{
|
||||
testDependency("scalatest", scalaTestVersion, uniformTestOrg, scalaVersion) ++
|
||||
testDependency("specs", specsVersion, uniformTestOrg, scalaVersion) ++
|
||||
testDependency("scalacheck", "1.5", false, scalaVersion)
|
||||
}
|
||||
} ++
|
||||
scalaDependency("scala-compiler", scalaVersion) ++ scalaDependency("scala-library", scalaVersion) ++
|
||||
{
|
||||
if(scalaVersion == conf_2_8_0)
|
||||
<dependency org="jline" name="jline" rev="0.9.94" transitive="false" conf={depConf(conf_2_8_0)}/>
|
||||
else
|
||||
NodeSeq.Empty
|
||||
}
|
||||
}
|
||||
else
|
||||
Nil
|
||||
}
|
||||
private def scalaDependency(name: String, scalaVersion: Configuration) =
|
||||
<dependency org="org.scala-lang" name={name} rev={scalaVersion.toString} conf={depConf(scalac(scalaVersion))}/>
|
||||
|
||||
/** Creates a comment containing the version of Scala*/
|
||||
private def scalaComment(scalaVersion: Configuration) = scala.xml.Comment("Scala " + scalaVersion)
|
||||
/** Creates a dependency element for a test. See 'testOrg' for a description of uniformTestOrg.*/
|
||||
|
||||
private def testDependency(name: String, version: String, uniformTestOrg: Boolean, baseConf: Configuration) =
|
||||
<dependency org={testOrg(name, uniformTestOrg)} name={name} rev={version} transitive="false" conf={depConf(optional(baseConf))}/>
|
||||
|
||||
/** Returns the organization for the given test library. If uniform is true,
|
||||
* the 'org.scala-tools.testing' organization is used. Otherwise, 'org.' is prefixed to the module name.*/
|
||||
private def testOrg(name: String, uniform: Boolean) =
|
||||
if(uniform) "org.scala-tools.testing"
|
||||
else "org." + name
|
||||
|
||||
/** Disable filtering Scala jars from dependency management, because we need them and are putting them
|
||||
* in custom configurations and are using them in a separate process than sbt runs in.*/
|
||||
override def filterScalaJars = false
|
||||
|
||||
/** The lib directory is now only for building using the 'build' script.*/
|
||||
override def unmanagedClasspath = path("ignore_lib_directory")
|
||||
/** When cross-compiling, replace mainCompilePath with the classes directory for the version being compiled.*/
|
||||
override def fullUnmanagedClasspath(config: Configuration) =
|
||||
if( (Configurations.Default :: Configurations.defaultMavenConfigurations) contains config)
|
||||
super.fullUnmanagedClasspath(config)
|
||||
else
|
||||
classesPath(config) +++ mainResourcesPath
|
||||
|
||||
// include the optional-<version> dependencies as well as the ones common across all scala versions
|
||||
def optionalClasspath(version: Configuration) = fullClasspath(optional(version)) +++ super.optionalClasspath
|
||||
|
||||
private val CompilerMainClass = "scala.tools.nsc.Main"
|
||||
// use a publish configuration that publishes the 'base' + all <version> configurations (base is required because
|
||||
// the <version> configurations extend it)
|
||||
private val conf = new DefaultPublishConfiguration("local", "release")
|
||||
{
|
||||
override def configurations: Option[Iterable[Configuration]] = Some(config(base) :: buildConfigurations)
|
||||
}
|
||||
// the actions for cross-version packaging and publishing
|
||||
lazy val crossPackage = buildConfigurations.map(packageForScala)
|
||||
lazy val crossDeliverLocal = deliverTask(conf, updateOptions) dependsOn(crossPackage : _*)
|
||||
lazy val crossPublishLocal = publishTask(conf, updateOptions) dependsOn(crossDeliverLocal)
|
||||
// Creates a task that produces a packaged sbt compiled against Scala scalaVersion.
|
||||
// The jar is named 'sbt_<scala-version>-<sbt-version>.jar'
|
||||
private def packageForScala(scalaVersion: Configuration) =
|
||||
{
|
||||
val classes = classesPath(scalaVersion) ** "*"
|
||||
val jarName = crossJarName(scalaVersion)
|
||||
val packageActionName = crossActionName("package", scalaVersion)
|
||||
val compileAction = compileForScala(scalaVersion) named(crossActionName("compile", scalaVersion))
|
||||
packageTask(classes +++ mainResources, outputPath, jarName, packageOptions) dependsOn(compileAction) named(packageActionName)
|
||||
}
|
||||
private def crossActionName(base: String, scalaVersion: Configuration) = base + " [ " + scalaVersion.toString + " ] "
|
||||
private def crossJarName(scalaVersion: Configuration) = sbt(scalaVersion) + "-" + version.toString + ".jar"
|
||||
// This creates a task that compiles sbt against the given version of scala. Classes are put in classes-<scalaVersion>.
|
||||
private def compileForScala(version: Configuration)=
|
||||
task
|
||||
{
|
||||
val classes = classesPath(version)
|
||||
val toClean = (outputPath / crossJarName(version)) +++ (classes ** "*")
|
||||
val setupResult =
|
||||
FileUtilities.clean(toClean.get, true, log) orElse
|
||||
FileUtilities.createDirectory(classes, log)
|
||||
for(err <- setupResult) log.error(err)
|
||||
// the classpath containing the scalac compiler
|
||||
val compilerClasspath = concatPaths(fullClasspath(scalac(version)))
|
||||
|
||||
// The libraries to compile sbt against
|
||||
val classpath = fullClasspath(version) +++ optionalClasspath(version)
|
||||
val sources: List[String] = pathListStrings(mainSources)
|
||||
val compilerOptions = List("-cp", concatPaths(classpath), "-d", classes.toString)
|
||||
val compilerArguments: List[String] = compilerOptions ::: sources
|
||||
|
||||
// the compiler classpath has to be appended to the boot classpath to work properly
|
||||
val allArguments = "-Xmx512M" :: ("-Xbootclasspath/a:" + compilerClasspath) :: CompilerMainClass :: compilerArguments
|
||||
log.debug("Running external compiler with command: java " + allArguments.mkString(" "))
|
||||
val exitValue = Process("java", allArguments) ! log
|
||||
if(exitValue == 0)
|
||||
None
|
||||
else
|
||||
Some("Nonzero exit value (" + exitValue + ") when calling scalac " + version + " with options: \n" + compilerOptions.mkString(" "))
|
||||
}
|
||||
private def concatPaths(p: PathFinder): String = Path.makeString(p.get)
|
||||
private def pathListStrings(p: PathFinder): List[String] = p.get.map(_.absolutePath).toList
|
||||
private def classesPath(scalaVersion: Configuration) = ("target" / ("classes-" + scalaVersion.toString)) ##
|
||||
}
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
import sbt._
|
||||
|
||||
import LoaderProject._
|
||||
import java.io.File
|
||||
|
||||
// a project for the sbt launcher
|
||||
// the main content of this project definition is setting up and running proguard
|
||||
// to combine and compact all dependencies into a single jar
|
||||
protected/* removes the ambiguity as to which project is the entry point by making this class non-public*/
|
||||
class LoaderProject(info: ProjectInfo) extends DefaultProject(info)
|
||||
{
|
||||
val mainClassName = "sbt.boot.Boot"
|
||||
val baseName = "sbt-launcher"
|
||||
val proguardConfigurationPath: Path = outputPath / "proguard.pro"
|
||||
lazy val outputJar: Path = rootProject.outputPath / (baseName + "-" + version + ".jar")
|
||||
def rootProjectDirectory = rootProject.info.projectPath
|
||||
|
||||
override def mainClass = Some(mainClassName)
|
||||
override def defaultJarBaseName = baseName + "-" + version.toString
|
||||
|
||||
/****** Resources *****/
|
||||
def extraResources = descendents(info.projectPath / "licenses", "*") +++ "LICENSE" +++ "NOTICE"
|
||||
override def mainResources = super.mainResources +++ extraResources
|
||||
|
||||
/****** Dependencies *******/
|
||||
val defaultConfig = config("default")
|
||||
val toolsConfig = config("tools")
|
||||
val ivy = "org.apache.ivy" % "ivy" % "2.0.0"
|
||||
val proguardJar = "net.sf.proguard" % "proguard" % "4.3" % "tools->default"
|
||||
|
||||
/******** Proguard *******/
|
||||
lazy val proguard = proguardTask dependsOn(`package`, writeProguardConfiguration) describedAs(ProguardDescription)
|
||||
lazy val writeProguardConfiguration = writeProguardConfigurationTask dependsOn `package` describedAs WriteProguardDescription
|
||||
|
||||
private def proguardTask =
|
||||
task
|
||||
{
|
||||
FileUtilities.clean(outputJar :: Nil, log)
|
||||
val proguardClasspath = managedClasspath(toolsConfig)
|
||||
val proguardClasspathString = Path.makeString(proguardClasspath.get)
|
||||
val configFile = proguardConfigurationPath.asFile.getAbsolutePath
|
||||
val exitValue = Process("java", List("-Xmx128M", "-cp", proguardClasspathString, "proguard.ProGuard", "@" + configFile)) ! log
|
||||
if(exitValue == 0) None else Some("Proguard failed with nonzero exit code (" + exitValue + ")")
|
||||
}
|
||||
private def writeProguardConfigurationTask =
|
||||
task
|
||||
{
|
||||
// these are classes that need to be explicitly kept because they are loaded reflectively
|
||||
val ivyKeepResolvers =
|
||||
"org.apache.ivy.plugins.resolver.URLResolver" ::
|
||||
"org.apache.ivy.plugins.resolver.IBiblioResolver" ::
|
||||
Nil
|
||||
// the template for the proguard configuration file
|
||||
val outTemplate = """
|
||||
|-dontoptimize
|
||||
|-dontobfuscate
|
||||
|-dontnote
|
||||
|-dontwarn
|
||||
|-libraryjars %s
|
||||
|-injars %s(!META-INF/**,!fr/**,!**/antlib.xml,!**/*.png)
|
||||
|-injars %s(!META-INF/**)
|
||||
|%s
|
||||
|-outjars %s
|
||||
|-ignorewarnings
|
||||
|%s
|
||||
|%s
|
||||
|-keep public class %s {
|
||||
| public static void main(java.lang.String[]);
|
||||
|}"""
|
||||
|
||||
val defaultJar = (outputPath / defaultJarName).asFile.getAbsolutePath
|
||||
log.debug("proguard configuration using main jar " + defaultJar)
|
||||
val ivyKeepOptions = ivyKeepResolvers.map("-keep public class " + _ + allPublic).mkString("\n")
|
||||
val runtimeClasspath = runClasspath.get.map(_.asFile).toList
|
||||
val jlineJars = runtimeClasspath.filter(isJLineJar)
|
||||
val externalDependencies = (mainCompileConditional.analysis.allExternals).map(_.getAbsoluteFile).filter(_.getName.endsWith(".jar"))
|
||||
log.debug("proguard configuration external dependencies: \n\t" + externalDependencies.mkString("\n\t"))
|
||||
// partition jars from the external jar dependencies of this project by whether they are located in the project directory
|
||||
// if they are, they are specified with -injars, otherwise they are specified with -libraryjars
|
||||
val (externalJars, libraryJars) = externalDependencies.toList.partition(jar => Path.relativize(rootProjectDirectory, jar).isDefined)
|
||||
log.debug("proguard configuration library jars locations: " + libraryJars.mkString(", "))
|
||||
// pull out Ivy in order to exclude resources inside
|
||||
val (ivyJars, externalJarsNoIvy) = externalJars.partition(_.getName.startsWith("ivy"))
|
||||
log.debug("proguard configuration ivy jar location: " + ivyJars.mkString(", "))
|
||||
// the loader uses JLine, so there is a dependency on the compiler (because JLine is distributed with the compiler,
|
||||
// it finds the JLine classes from the compiler jar instead of the jline jar on the classpath), but we don't want to
|
||||
// include the version of JLine from the compiler.
|
||||
val includeExternalJars = externalJarsNoIvy.filter(jar => !isJarX(jar, "scala-compiler"))
|
||||
// exclude properties files and manifests from scala-library jar
|
||||
val inJars = (defaultJar :: includeExternalJars.map( _ + "(!META-INF/**,!*.properties)")).map("-injars " + _).mkString("\n")
|
||||
|
||||
withJar(ivyJars, "Ivy") { ivyJar =>
|
||||
withJar(jlineJars, "JLine") { jlineJar =>
|
||||
val proguardConfiguration =
|
||||
outTemplate.stripMargin.format(libraryJars.mkString(File.pathSeparator),
|
||||
ivyJar.getAbsolutePath, jlineJar.getAbsolutePath,
|
||||
inJars, outputJar.absolutePath, ivyKeepOptions, keepJLine, mainClassName)
|
||||
log.debug("Proguard configuration written to " + proguardConfigurationPath)
|
||||
FileUtilities.write(proguardConfigurationPath.asFile, proguardConfiguration, log)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def withJar(files: List[File], name: String)(f: File => Option[String]): Option[String] =
|
||||
files match
|
||||
{
|
||||
case Nil => Some(name + " not present (try running update)")
|
||||
case jar :: _ => f(jar)
|
||||
}
|
||||
private def isJLineJar(file: File) = isJarX(file, "jline")
|
||||
private def isJarX(file: File, x: String) =
|
||||
{
|
||||
val name = file.getName
|
||||
name.startsWith(x) && name.endsWith(".jar")
|
||||
}
|
||||
// class body declaration for proguard that keeps all public members
|
||||
private val allPublic = " {\n public * ;\n}"
|
||||
|
||||
private val keepJLine =
|
||||
"""
|
||||
|-keep public class jline.** {
|
||||
| public protected *;
|
||||
|}
|
||||
""".stripMargin
|
||||
}
|
||||
object LoaderProject
|
||||
{
|
||||
val ProguardDescription = "Produces the final compacted jar that contains only the minimum classes needed using proguard."
|
||||
val WriteProguardDescription = "Creates the configuration file to use with proguard."
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
import sbt._
|
||||
|
||||
import java.io.File
|
||||
|
||||
class SbtProject(info: ProjectInfo) extends ParentProject(info)
|
||||
{
|
||||
// Launcher sub project.
|
||||
lazy val boot = project("boot", "Simple Build Tool Loader", new LoaderProject(_))
|
||||
// Main builder sub project
|
||||
lazy val main = project(info.projectPath, "Simple Build Tool", new MainProject(_))
|
||||
// One-shot build for users building from trunk
|
||||
lazy val fullBuild = task { None } dependsOn(boot.proguard, main.crossPublishLocal) describedAs
|
||||
"Builds the loader and builds main sbt against all supported versions of Scala and installs to the local repository."
|
||||
|
||||
override def shouldCheckOutputDirectories = false
|
||||
override def baseUpdateOptions = QuietUpdate :: Nil
|
||||
|
||||
override def parallelExecution = true
|
||||
override def deliverLocalAction = noAction
|
||||
private def noAction = task { None }
|
||||
override def publishLocalAction = noAction
|
||||
}
|
||||
|
||||
protected class MainProject(val info: ProjectInfo) extends CrossCompileProject
|
||||
{
|
||||
override def mainScalaSources =
|
||||
if(Project.currentScalaVersion.map(_.startsWith("2.8")).getOrElse(false)) // cannot compile against test libraries currently
|
||||
Path.lazyPathFinder { super.mainScalaSources.get.filter(_.asFile.getName.endsWith("TestFrameworkImpl.scala")) }
|
||||
else
|
||||
super.mainScalaSources
|
||||
override def defaultJarBaseName = "sbt_" + version.toString
|
||||
/** Additional resources to include in the produced jar.*/
|
||||
def extraResources = descendents(info.projectPath / "licenses", "*") +++ "LICENSE" +++ "NOTICE"
|
||||
override def mainResources = super.mainResources +++ extraResources
|
||||
override def mainClass = Some("sbt.Main")
|
||||
override def testOptions = ExcludeTests("sbt.ReflectiveSpecification" :: "sbt.ProcessSpecification" :: Nil) :: super.testOptions.toList
|
||||
|
||||
// ======== Scripted testing ==========
|
||||
|
||||
def sbtTestResources = testResourcesPath / "sbt-test-resources"
|
||||
|
||||
lazy val testNoScripted = super.testAction
|
||||
override def testAction = testNoScripted dependsOn(scripted)
|
||||
lazy val scripted = scriptedTask dependsOn(testCompile, `package`)
|
||||
def scriptedTask =
|
||||
task
|
||||
{
|
||||
log.info("Running scripted tests...")
|
||||
log.info("")
|
||||
// load ScriptedTests using a ClassLoader that loads from the project classpath so that the version
|
||||
// of sbt being built is tested, not the one doing the building.
|
||||
val loader = ScriptedLoader(scriptedClasspath.toArray)
|
||||
val scriptedClass = Class.forName(ScriptedClassName, true, loader)
|
||||
val scriptedConstructor = scriptedClass.getConstructor(classOf[File], classOf[Function2[String, String, Boolean]])
|
||||
val runner = scriptedConstructor.newInstance(sbtTestResources.asFile, filter)
|
||||
runner.asInstanceOf[{def scriptedTests(log: Logger): Option[String]}].scriptedTests(log)
|
||||
}
|
||||
/** The classpath to use for scripted tests. This ensures that the version of sbt being built it the one used for testing.*/
|
||||
private def scriptedClasspath =
|
||||
{
|
||||
val buildClasspath = classOf[SbtProject]. getProtectionDomain.getCodeSource.getLocation.toURI.toURL
|
||||
val scalacJar = FileUtilities.scalaCompilerJar.toURI.toURL
|
||||
val ivy = runClasspath.get.filter(_.asFile.getName.startsWith("ivy-")).map(_.asURL).toList
|
||||
val builtSbtJar = (outputPath / defaultJarName).asURL
|
||||
builtSbtJar :: buildClasspath :: scalacJar :: ivy
|
||||
}
|
||||
|
||||
val ScriptedClassName = "scripted.ScriptedTests"
|
||||
|
||||
val filter = (group: String, name: String) => true
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
import sbt._
|
||||
|
||||
import java.net.URL
|
||||
|
||||
package sbt { // need access to LoaderBase, which is private in package sbt
|
||||
object ScriptedLoader
|
||||
{
|
||||
def apply(paths: Array[URL]): ClassLoader = new ScriptedLoader(paths)
|
||||
}
|
||||
private class ScriptedLoader(paths: Array[URL]) extends LoaderBase(paths, classOf[ScriptedLoader].getClassLoader)
|
||||
{
|
||||
private val delegateFor = List("sbt.Logger", "sbt.LogEvent", "sbt.SetLevel", "sbt.Success", "sbt.Log", "sbt.SetTrace", "sbt.Trace", "sbt.ControlEvent")
|
||||
def doLoadClass(className: String): Class[_] =
|
||||
{
|
||||
// Logger needs to be loaded from the version of sbt building the project because we need to pass
|
||||
// a Logger from that loader into ScriptedTests.
|
||||
// All other sbt classes should be loaded from the project classpath so that we test those classes with 'scripted'
|
||||
if(!shouldDelegate(className) && (className.startsWith("sbt.") || className.startsWith("scripted.") || className.startsWith("scala.tools.")))
|
||||
findClass(className)
|
||||
else
|
||||
selfLoadClass(className)
|
||||
}
|
||||
|
||||
private def shouldDelegate(className: String) = delegateFor.exists(check => isNestedOrSelf(className, check))
|
||||
private def isNestedOrSelf(className: String, checkAgainst: String) =
|
||||
className == checkAgainst || className.startsWith(checkAgainst + "$")
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
|
||||
package scripted
|
||||
|
||||
import sbt._
|
||||
import java.io.File
|
||||
|
||||
trait ScriptedTestFilter extends NotNull
|
||||
{
|
||||
def accept(group: String, name: String): Boolean
|
||||
}
|
||||
class BasicFilter(f: (String, String) => Boolean) extends ScriptedTestFilter
|
||||
{
|
||||
def accept(group: String, name: String) = f(group, name)
|
||||
}
|
||||
|
||||
object AcceptAllFilter extends ScriptedTestFilter
|
||||
{
|
||||
def accept(group: String, name: String): Boolean = true
|
||||
}
|
||||
class ScriptedTests(testResources: Resources, filter: ScriptedTestFilter) extends NotNull
|
||||
{
|
||||
def this(resourceBaseDirectory: File, filter: (String, String) => Boolean) = this(new Resources(resourceBaseDirectory), new BasicFilter(filter))
|
||||
def this(resourceBaseDirectory: File, filter: ScriptedTestFilter) = this(new Resources(resourceBaseDirectory), filter)
|
||||
def this(testResources: Resources) = this(testResources, AcceptAllFilter)
|
||||
def this(resourceBaseDirectory: File) = this(new Resources(resourceBaseDirectory))
|
||||
|
||||
val ScriptFilename = "test"
|
||||
import testResources._
|
||||
|
||||
private def includeDirectory(file: File) = file.getName != ".svn"
|
||||
def scriptedTests(log: Logger): Option[String] =
|
||||
{
|
||||
System.setProperty("sbt.scala.version", "")
|
||||
var success = true
|
||||
for(group <- baseDirectory.listFiles(DirectoryFilter) if includeDirectory(group))
|
||||
{
|
||||
log.info("Test group " + group.getName)
|
||||
for(test <- group.listFiles(DirectoryFilter) if includeDirectory(test))
|
||||
{
|
||||
val testName = test.getName
|
||||
if(!filter.accept(group.getName, testName))
|
||||
log.warn(" Test " + testName + " skipped.")
|
||||
else
|
||||
scriptedTest(test, log) match
|
||||
{
|
||||
case Some(err) =>
|
||||
log.error(" Test " + testName + " failed: " + err)
|
||||
success = false
|
||||
case None => log.info(" Test " + testName + " succeeded.")
|
||||
}
|
||||
}
|
||||
}
|
||||
if(success)
|
||||
None
|
||||
else
|
||||
Some("One or more tests failed.")
|
||||
}
|
||||
|
||||
def scriptedTest(group: String, name: String, log: Logger): Option[String] =
|
||||
readOnlyResourceDirectory(group, name).fold(err => Some(err), testDirectory => scriptedTest(testDirectory, log))
|
||||
def scriptedTest(testDirectory: File, log: Logger): Option[String] =
|
||||
{
|
||||
(for(script <- (new TestScriptParser(testDirectory, log)).parse(new File(testDirectory, ScriptFilename)).right;
|
||||
u <- withProject(testDirectory, log)(script).right )
|
||||
yield u).left.toOption
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,269 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
|
||||
package scripted
|
||||
|
||||
import sbt._
|
||||
import java.io.{BufferedReader, File, InputStreamReader}
|
||||
|
||||
/*
|
||||
statement*
|
||||
statement ::= ('$' | '>') word+ '[' word ']'
|
||||
word ::= [^ \[\]]+
|
||||
comment ::= '#' [^ \n\r]* ('\n' | '\r' | eof)
|
||||
*/
|
||||
import scala.util.parsing.combinator._
|
||||
import scala.util.parsing.input.Positional
|
||||
|
||||
import TestScriptParser._
|
||||
private class TestScriptParser(baseDirectory: File, log: Logger) extends RegexParsers with NotNull
|
||||
{
|
||||
type Statement = Project => Either[String, ReloadProject]
|
||||
type PStatement = Statement with Positional
|
||||
|
||||
private def evaluateList(list: List[PStatement])(p: Project): WithProjectResult[Unit] =
|
||||
list match
|
||||
{
|
||||
case Nil => ValueResult(())
|
||||
case head :: tail =>
|
||||
head(p) match
|
||||
{
|
||||
case Left(msg) => new ErrorResult(msg)
|
||||
case Right(reload) => ContinueResult(p =>evaluateList(tail)(p), reload)
|
||||
}
|
||||
}
|
||||
|
||||
def script: Parser[Project => WithProjectResult[Unit]] = rep1(space ~> statement <~ space) ^^ evaluateList
|
||||
def statement: Parser[PStatement] =
|
||||
positioned
|
||||
{
|
||||
(StartRegex ~! rep1(word) ~! "[" ~! word ~! "]") ^^
|
||||
{
|
||||
case start ~ command ~ open ~ result ~ close =>
|
||||
val successExpected = result.toLowerCase == SuccessLiteral.toLowerCase
|
||||
new Statement with Positional
|
||||
{ selfPositional =>
|
||||
def apply(p: Project) =
|
||||
{
|
||||
val result =
|
||||
try
|
||||
{
|
||||
start match
|
||||
{
|
||||
case CommandStart => evaluateCommand(command, successExpected, selfPositional)(p)
|
||||
case ActionStart => evaluateAction(command, successExpected)(p).toLeft(NoReload)
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
case e: Exception =>
|
||||
log.trace(e)
|
||||
Left(e.toString)
|
||||
}
|
||||
result.left.map(message => linePrefix(this) + message)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
private def linePrefix(p: Positional) = "{line " + p.pos.line + "} "
|
||||
def space = """(\s+|(\#[^\n\r]*))*""".r
|
||||
def word: Parser[String] = ("\'" ~> "[^'\n\r]*".r <~ "\'") | ("\"" ~> "[^\"\n\r]*".r <~ "\"") | WordRegex
|
||||
def parse(scriptFile: File): Either[String, Project => WithProjectResult[Unit]] =
|
||||
{
|
||||
def parseReader(reader: java.io.Reader) =
|
||||
parseAll(script, reader) match
|
||||
{
|
||||
case Success(result, next) => Right(result)
|
||||
case err: NoSuccess =>
|
||||
{
|
||||
val pos = err.next.pos
|
||||
Left("Could not parse test script '" + scriptFile.getCanonicalPath +
|
||||
"' (" + pos.line + "," + pos.column + "): " + err.msg)
|
||||
}
|
||||
}
|
||||
FileUtilities.readValue(scriptFile, log)(parseReader)
|
||||
}
|
||||
|
||||
private def scriptError(message: String): Some[String] = Some("Test script error: " + message)
|
||||
private def wrongArguments(commandName: String, args: List[String]): Some[String] =
|
||||
scriptError("Command '" + commandName + "' does not accept arguments (found '" + spacedString(args) + "').")
|
||||
private def wrongArguments(commandName: String, requiredArgs: String, args: List[String]): Some[String] =
|
||||
scriptError("Wrong number of arguments to " + commandName + " command. " + requiredArgs + " required, found: '" + spacedString(args) + "'.")
|
||||
private def evaluateCommand(command: List[String], successExpected: Boolean, position: Positional)(project: Project): Either[String, ReloadProject] =
|
||||
{
|
||||
command match
|
||||
{
|
||||
case "reload" :: Nil => Right(if(successExpected) new ReloadSuccessExpected(linePrefix(position)) else ReloadErrorExpected)
|
||||
case x => evaluateCommandNoReload(x, successExpected)(project).toLeft(NoReload)
|
||||
}
|
||||
}
|
||||
private def evaluateCommandNoReload(command: List[String], successExpected: Boolean)(project: Project): Option[String] =
|
||||
{
|
||||
evaluate(successExpected, "Command '" + command.firstOption.getOrElse("") + "'", project)
|
||||
{
|
||||
command match
|
||||
{
|
||||
case Nil => scriptError("No command specified.")
|
||||
case "touch" :: paths => touch(paths, project)
|
||||
case "delete" :: paths => delete(paths, project)
|
||||
case "mkdir" :: paths => makeDirectories(paths, project)
|
||||
case "copy-file" :: from :: to :: Nil => copyFile(from, to, project)
|
||||
case "copy-file" :: args => wrongArguments("copy-file", "Two paths", args)
|
||||
case "sync" :: from :: to :: Nil => sync(from, to, project)
|
||||
case "sync" :: args => wrongArguments("sync", "Two directory paths", args)
|
||||
case "copy" :: paths => copy(paths, project)
|
||||
case "exists" :: paths => exists(paths, project)
|
||||
case "absent" :: paths => absent(paths, project)
|
||||
case "pause" :: Nil => readLine("Press enter to continue. "); println(); None
|
||||
case "pause" :: args => wrongArguments("pause", args)
|
||||
case "newer" :: a :: b :: Nil => newer(a, b, project)
|
||||
case "newer" :: args => wrongArguments("newer", "Two paths", args)
|
||||
case "sleep" :: time :: Nil => trap("Error while sleeping:") { Thread.sleep(time.toLong) }
|
||||
case "sleep" :: args => wrongArguments("sleep", "Time in milliseconds", args)
|
||||
case "exec" :: command :: args => execute(command, args, project)
|
||||
case "exec" :: other => wrongArguments("exec", "Command and arguments", other)
|
||||
case "reload" :: args => wrongArguments("reload", args)
|
||||
case unknown :: arguments => scriptError("Unknown command " + unknown)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def foreachBufferedLogger(project: Project)(f: BufferedLogger => Unit)
|
||||
{
|
||||
project.topologicalSort.foreach(p => p.log match { case buffered: BufferedLogger => f(buffered); case _ => () })
|
||||
}
|
||||
private def evaluate(successExpected: Boolean, label: String, project: Project)(body: => Option[String]): Option[String] =
|
||||
{
|
||||
def startRecordingLog() { foreachBufferedLogger(project)(_.startRecording()) }
|
||||
def playLog() { foreachBufferedLogger(project)(_.playAll()) }
|
||||
def stopLog() { foreachBufferedLogger(project)(_.stop()) }
|
||||
|
||||
startRecordingLog()
|
||||
val result =
|
||||
body match
|
||||
{
|
||||
case None =>
|
||||
if(successExpected) None
|
||||
else
|
||||
{
|
||||
playLog()
|
||||
Some(label + " succeeded (expected failure).")
|
||||
}
|
||||
case Some(failure) =>
|
||||
if(successExpected)
|
||||
{
|
||||
playLog()
|
||||
Some(label + " failed (expected success): " + failure)
|
||||
}
|
||||
else None
|
||||
}
|
||||
stopLog()
|
||||
result
|
||||
}
|
||||
private def evaluateAction(action: List[String], successExpected: Boolean)(project: Project): Option[String] =
|
||||
{
|
||||
def actionToString = action.mkString(" ")
|
||||
action match
|
||||
{
|
||||
case Nil => scriptError("No action specified.")
|
||||
case head :: Nil if project.taskNames.toSeq.contains(head)=>
|
||||
evaluate(successExpected, "Action '" + actionToString + "'", project)(project.act(head))
|
||||
case head :: tail =>
|
||||
evaluate(successExpected, "Method '" + actionToString + "'", project)(project.call(head, tail.toArray))
|
||||
}
|
||||
}
|
||||
private def spacedString[T](l: Seq[T]) = l.mkString(" ")
|
||||
private def wrap(result: Option[String]) = result.flatMap(scriptError)
|
||||
private def trap(errorPrefix: String)(action: => Unit) = wrap( Control.trapUnit(errorPrefix, log) { action; None } )
|
||||
|
||||
private def fromStrings(paths: List[String], project: Project) = paths.map(path => fromString(path, project))
|
||||
private def fromString(path: String, project: Project) = Path.fromString(project.info.projectPath, path)
|
||||
private def touch(paths: List[String], project: Project) =
|
||||
if(paths.isEmpty)
|
||||
scriptError("No paths specified for touch command.")
|
||||
else
|
||||
wrap(lazyFold(paths) { path => FileUtilities.touch(fromString(path, project), log) })
|
||||
|
||||
private def delete(paths: List[String], project: Project) =
|
||||
if(paths.isEmpty)
|
||||
scriptError("No paths specified for delete command.")
|
||||
else
|
||||
wrap(FileUtilities.clean(fromStrings(paths, project), true, log))
|
||||
private def sync(from: String, to: String, project: Project) =
|
||||
wrap(FileUtilities.sync(fromString(from, project), fromString(to, project), log))
|
||||
private def copyFile(from: String, to: String, project: Project) =
|
||||
wrap(FileUtilities.copyFile(fromString(from, project), fromString(to, project), log))
|
||||
private def copy(paths: List[String], project: Project) =
|
||||
paths match
|
||||
{
|
||||
case Nil => scriptError("No paths specified for copy command.")
|
||||
case path :: Nil => scriptError("No destination specified for copy command.")
|
||||
case _ =>
|
||||
val mapped = fromStrings(paths, project).toArray
|
||||
val last = mapped.length - 1
|
||||
wrap(FileUtilities.copy(mapped.take(last), mapped(last), log).left.toOption)
|
||||
}
|
||||
private def makeDirectories(paths: List[String], project: Project) =
|
||||
fromStrings(paths, project) match
|
||||
{
|
||||
case Nil => scriptError("No paths specified for mkdir command.")
|
||||
case p => FileUtilities.createDirectories(p, project.log)
|
||||
}
|
||||
private def newer(a: String, b: String, project: Project) =
|
||||
trap("Error testing if '" + a + "' is newer than '" + b + "'")
|
||||
{
|
||||
val pathA = fromString(a, project)
|
||||
val pathB = fromString(b, project)
|
||||
pathA.exists && (!pathB.exists || pathA.lastModified > pathB.lastModified)
|
||||
}
|
||||
private def exists(paths: List[String], project: Project) =
|
||||
fromStrings(paths, project).filter(!_.exists) match
|
||||
{
|
||||
case Nil => None
|
||||
case x => Some("File(s) did not exist: " + x.mkString("[ ", " , ", " ]"))
|
||||
}
|
||||
private def absent(paths: List[String], project: Project) =
|
||||
fromStrings(paths, project).filter(_.exists) match
|
||||
{
|
||||
case Nil => None
|
||||
case x => Some("File(s) existed: " + x.mkString("[ ", " , ", " ]"))
|
||||
}
|
||||
private def execute(command: String, args: List[String], project: Project) =
|
||||
{
|
||||
if(command.trim.isEmpty)
|
||||
Some("Command was empty.")
|
||||
else
|
||||
{
|
||||
Control.trapUnit("Error running command: ", project.log)
|
||||
{
|
||||
val builder = new java.lang.ProcessBuilder((command :: args).toArray : _*).directory(project.info.projectDirectory)
|
||||
val exitValue = Process(builder) ! log
|
||||
if(exitValue == 0)
|
||||
None
|
||||
else
|
||||
Some("Nonzero exit value (" + exitValue + ")")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
private object TestScriptParser
|
||||
{
|
||||
val SuccessLiteral = "success"
|
||||
val Failure = "error"
|
||||
val CommandStart = "$"
|
||||
val ActionStart = ">"
|
||||
val WordRegex = """[^ \[\]\s'\"][^ \[\]\s]*""".r
|
||||
val StartRegex = ("[" + CommandStart + ActionStart + "]").r
|
||||
|
||||
final def lazyFold[T](list: List[T])(f: T => Option[String]): Option[String] =
|
||||
list match
|
||||
{
|
||||
case Nil => None
|
||||
case head :: tail =>
|
||||
f(head) match
|
||||
{
|
||||
case None => lazyFold(tail)(f)
|
||||
case x => x
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
<plugin>
|
||||
<name>sbt-analyze</name>
|
||||
<classname>sbt.Analyzer</classname>
|
||||
</plugin>
|
||||
|
|
@ -0,0 +1,220 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
trait TaskAnalysis[Source, Product, External] extends NotNull
|
||||
{
|
||||
import scala.collection.Set
|
||||
def save(): Option[String]
|
||||
def revert(): Option[String]
|
||||
def clear(): Unit
|
||||
|
||||
def allSources: Set[Source]
|
||||
def allProducts: Set[Product]
|
||||
def allExternals: Set[External]
|
||||
|
||||
def sourceDependencies(source: Source): Option[Set[Source]]
|
||||
def products(source: Source): Option[Set[Product]]
|
||||
def externalDependencies(external: External): Option[Set[Source]]
|
||||
|
||||
def addSource(source: Source): Unit
|
||||
def addExternalDependency(dependsOn: External, source: Source): Unit
|
||||
def addSourceDependency(dependsOn: Source, source: Source): Unit
|
||||
def addProduct(source: Source, product: Product): Unit
|
||||
|
||||
def removeSource(source: Source): Unit
|
||||
def removeDependent(source: Source): Unit
|
||||
def removeDependencies(source: Source): Option[Set[Source]]
|
||||
def removeExternalDependency(external: External): Unit
|
||||
}
|
||||
|
||||
import java.io.File
|
||||
import BasicAnalysis._
|
||||
import impl.MapUtilities.{add, all, read, mark, readOnlyIterable, write}
|
||||
import scala.collection.mutable.{HashMap, HashSet, ListBuffer, Map, Set}
|
||||
|
||||
sealed class BasicAnalysis(analysisPath: Path, projectPath: Path, log: Logger) extends TaskAnalysis[Path, Path, File]
|
||||
{
|
||||
private val sourceDependencyMap: Map[Path, Set[Path]] = new HashMap
|
||||
private val productMap: Map[Path, Set[Path]] = new HashMap
|
||||
private val externalDependencyMap: Map[File, Set[Path]] = new HashMap
|
||||
|
||||
final type AnyMapToSource = Map[K, Set[Path]] forSome {type K}
|
||||
final type AnySourceMap = Map[Path, T] forSome {type T}
|
||||
final type AnySourceSetMap = Map[Path, Set[T]] forSome {type T}
|
||||
final type AnyMap = Map[K, V] forSome { type K; type V }
|
||||
|
||||
protected def mapsToClear = List[AnyMap](sourceDependencyMap, productMap, externalDependencyMap)
|
||||
protected def mapsToRemoveSource = List[AnySourceMap](sourceDependencyMap, productMap)
|
||||
protected def mapsToRemoveDependent = List[AnyMapToSource](sourceDependencyMap, externalDependencyMap)
|
||||
protected def mapsToMark = List[AnySourceSetMap](sourceDependencyMap, productMap)
|
||||
|
||||
def clear()
|
||||
{
|
||||
for(map <- mapsToClear)
|
||||
map.clear()
|
||||
}
|
||||
def removeSource(source: Path)
|
||||
{
|
||||
for(sourceProducts <- productMap.get(source))
|
||||
FileUtilities.clean(sourceProducts, true, log)
|
||||
for(map <- mapsToRemoveSource)
|
||||
map -= source
|
||||
}
|
||||
def removeSelfDependency(source: Path)
|
||||
{
|
||||
for(deps <- sourceDependencyMap.get(source))
|
||||
deps -= source
|
||||
}
|
||||
def removeDependent(source: Path)
|
||||
{
|
||||
for(map <- mapsToRemoveDependent; deps <- map.values)
|
||||
deps -= source
|
||||
}
|
||||
def removeDependencies(source: Path) = sourceDependencyMap.removeKey(source)
|
||||
def removeExternalDependency(dep: File) = externalDependencyMap.removeKey(dep.getAbsoluteFile)
|
||||
|
||||
def externalDependencies(external: File) = externalDependencyMap.get(external.getAbsoluteFile)
|
||||
def sourceDependencies(source: Path) = sourceDependencyMap.get(source)
|
||||
def products(sources: Iterable[Path]): Iterable[Path] =
|
||||
{
|
||||
val buffer = new ListBuffer[Path]
|
||||
for(source <- sources; sourceProducts <- productMap.get(source))
|
||||
buffer ++= sourceProducts
|
||||
buffer.readOnly
|
||||
}
|
||||
def products(source: Path) = productMap.get(source)
|
||||
|
||||
def allSources = sourceDependencyMap.keySet
|
||||
def allProducts: Set[Path] = HashSet(flatten(productMap.values.toList) : _*)
|
||||
def allExternals = externalDependencyMap.keySet
|
||||
|
||||
def allExternalDependencies = readOnlyIterable(externalDependencyMap)
|
||||
def allDependencies = readOnlyIterable(sourceDependencyMap)
|
||||
|
||||
def addSourceDependency(on: Path, from: Path) = add(on, from, sourceDependencyMap)
|
||||
def addExternalDependency(on: File, from: Path) = add(on.getAbsoluteFile, from, externalDependencyMap)
|
||||
def addProduct(source: Path, file: Path) = add(source, file, productMap)
|
||||
def addSource(source: Path) =
|
||||
{
|
||||
for(map <- mapsToMark)
|
||||
mark(source, map)
|
||||
}
|
||||
|
||||
import Format._ // get implicits for data types
|
||||
implicit val path: Format[Path] = Format.path(projectPath)
|
||||
implicit val pathSet: Format[Set[Path]] = Format.set
|
||||
|
||||
protected def backedMaps: Iterable[Backed[_,_]] =
|
||||
Backed(sourceDependencyMap, DependenciesLabel, DependenciesFileName) ::
|
||||
Backed(productMap, GeneratedLabel, GeneratedFileName) ::
|
||||
Backed(externalDependencyMap, ExternalDependenciesLabel, ExternalDependenciesFileName) ::
|
||||
Nil
|
||||
|
||||
def revert() = load()
|
||||
private def loadBacked[Key,Value](b: Backed[Key,Value]) = read(b.map, analysisPath / b.name, log)(b.keyFormat, b.valueFormat)
|
||||
private def storeBacked[Key,Value](b: Backed[Key,Value]) = write(b.map, b.label, analysisPath / b.name, log)(b.keyFormat, b.valueFormat)
|
||||
final def load(): Option[String] = Control.lazyFold(backedMaps.toList)(backed =>loadBacked(backed))
|
||||
final def save(): Option[String] = Control.lazyFold(backedMaps.toList)(backed => storeBacked(backed))
|
||||
}
|
||||
object BasicAnalysis
|
||||
{
|
||||
private def flatten(s: Iterable[Set[Path]]): Seq[Path] = s.flatMap(x => x.toSeq).toSeq
|
||||
|
||||
val GeneratedFileName = "generated_files"
|
||||
val DependenciesFileName = "dependencies"
|
||||
val ExternalDependenciesFileName = "external"
|
||||
|
||||
val GeneratedLabel = "Generated Classes"
|
||||
val DependenciesLabel = "Source Dependencies"
|
||||
val ExternalDependenciesLabel = "External Dependencies"
|
||||
|
||||
def load(analysisPath: Path, projectPath: Path, log: Logger): Either[String, BasicAnalysis] =
|
||||
{
|
||||
val analysis = new BasicAnalysis(analysisPath, projectPath, log)
|
||||
analysis.load().toLeft(analysis)
|
||||
}
|
||||
}
|
||||
object CompileAnalysis
|
||||
{
|
||||
val HashesFileName = "hashes"
|
||||
val TestsFileName = "tests"
|
||||
val ApplicationsFileName = "applications"
|
||||
val ProjectDefinitionsName = "projects"
|
||||
|
||||
val HashesLabel = "Source Hashes"
|
||||
val TestsLabel = "Tests"
|
||||
val ApplicationsLabel = "Classes with main methods"
|
||||
val ProjectDefinitionsLabel = "Project Definitions"
|
||||
|
||||
def load(analysisPath: Path, projectPath: Path, log: Logger): Either[String, CompileAnalysis] =
|
||||
{
|
||||
val analysis = new CompileAnalysis(analysisPath, projectPath, log)
|
||||
analysis.load().toLeft(analysis)
|
||||
}
|
||||
}
|
||||
import CompileAnalysis._
|
||||
import Format._ // get implicits for data types
|
||||
sealed class BasicCompileAnalysis protected (analysisPath: Path, projectPath: Path, log: Logger) extends BasicAnalysis(analysisPath, projectPath, log)
|
||||
{
|
||||
/*private */val hashesMap = new HashMap[Path, Array[Byte]]
|
||||
|
||||
override protected def mapsToClear = hashesMap :: super.mapsToClear
|
||||
override protected def mapsToRemoveSource = hashesMap :: super.mapsToRemoveSource
|
||||
|
||||
def setHash(source: Path, hash: Array[Byte]) { hashesMap(source) = hash }
|
||||
def clearHash(source: Path) { hashesMap.removeKey(source) }
|
||||
def hash(source: Path) = hashesMap.get(source)
|
||||
def clearHashes() { hashesMap.clear() }
|
||||
|
||||
def getClasses(sources: PathFinder, outputDirectory: Path): PathFinder =
|
||||
Path.lazyPathFinder
|
||||
{
|
||||
val basePath = (outputDirectory ##)
|
||||
for(c <- products(sources.get)) yield
|
||||
Path.relativize(basePath, c).getOrElse(c)
|
||||
}
|
||||
|
||||
implicit val stringSet: Format[Set[String]] = Format.set
|
||||
override protected def backedMaps = Backed(hashesMap, HashesLabel, HashesFileName) :: super.backedMaps.toList
|
||||
}
|
||||
private[sbt] final class BuilderCompileAnalysis(analysisPath: Path, projectPath: Path, log: Logger) extends BasicCompileAnalysis(analysisPath, projectPath, log)
|
||||
{
|
||||
private val projectDefinitionMap = new HashMap[Path, Set[String]]
|
||||
override protected def mapsToClear = projectDefinitionMap :: super.mapsToClear
|
||||
override protected def mapsToRemoveSource = projectDefinitionMap :: super.mapsToRemoveSource
|
||||
def allProjects = all(projectDefinitionMap)
|
||||
def addProjectDefinition(source: Path, className: String) = add(source, className, projectDefinitionMap)
|
||||
|
||||
override protected def backedMaps =
|
||||
Backed(projectDefinitionMap, ProjectDefinitionsLabel, ProjectDefinitionsName) ::
|
||||
super.backedMaps
|
||||
}
|
||||
final class CompileAnalysis(analysisPath: Path, projectPath: Path, log: Logger) extends BasicCompileAnalysis(analysisPath, projectPath, log)
|
||||
{
|
||||
private val testMap = new HashMap[Path, Set[TestDefinition]]
|
||||
private val applicationsMap = new HashMap[Path, Set[String]]
|
||||
def allTests = all(testMap)
|
||||
def allApplications = all(applicationsMap)
|
||||
def addTest(source: Path, test: TestDefinition) = add(source, test, testMap)
|
||||
def addApplication(source: Path, className: String) = add(source, className, applicationsMap)
|
||||
|
||||
def testSourceMap: Map[String, Path] =
|
||||
{
|
||||
val map = new HashMap[String, Path]
|
||||
for( (source, tests) <- testMap; test <- tests) map(test.testClassName) = source
|
||||
map
|
||||
}
|
||||
|
||||
override protected def mapsToClear = applicationsMap :: testMap :: super.mapsToClear
|
||||
override protected def mapsToRemoveSource = applicationsMap :: testMap :: super.mapsToRemoveSource
|
||||
|
||||
implicit val testSet: Format[Set[TestDefinition]] = Format.set
|
||||
override protected def backedMaps =
|
||||
Backed(testMap, TestsLabel, TestsFileName) ::
|
||||
Backed(applicationsMap, ApplicationsLabel, ApplicationsFileName) ::
|
||||
super.backedMaps
|
||||
}
|
||||
/** A map that is persisted in a properties file named 'name' and with 'label'. 'keyFormat' and 'valueFormat' are used to (de)serialize. */
|
||||
final case class Backed[Key, Value](map: Map[Key, Value], label: String, name: String)(implicit val keyFormat: Format[Key], val valueFormat: Format[Value]) extends NotNull
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
|
||||
object AnalysisCallback
|
||||
{
|
||||
private val map = new scala.collection.mutable.HashMap[Int, AnalysisCallback]
|
||||
private var nextID: Int = 0
|
||||
def register(callback: AnalysisCallback): Int =
|
||||
{
|
||||
val id = nextID
|
||||
nextID += 1
|
||||
map(id) = callback
|
||||
id
|
||||
}
|
||||
def apply(id: Int): Option[AnalysisCallback] = map.get(id)
|
||||
def unregister(id: Int)
|
||||
{
|
||||
map -= id
|
||||
}
|
||||
}
|
||||
|
||||
trait AnalysisCallback extends NotNull
|
||||
{
|
||||
/** The names of classes that the analyzer should find subclasses of.*/
|
||||
def superclassNames: Iterable[String]
|
||||
/** The base path for the project.*/
|
||||
def basePath: Path
|
||||
/** Called when the the given superclass could not be found on the classpath by the compiler.*/
|
||||
def superclassNotFound(superclassName: String): Unit
|
||||
/** Called before the source at the given location is processed. */
|
||||
def beginSource(sourcePath: Path): Unit
|
||||
/** Called when the a subclass of one of the classes given in <code>superclassNames</code> is
|
||||
* discovered.*/
|
||||
def foundSubclass(sourcePath: Path, subclassName: String, superclassName: String, isModule: Boolean): Unit
|
||||
/** Called to indicate that the source file <code>sourcePath</code> depends on the source file
|
||||
* <code>dependsOnPath</code>.*/
|
||||
def sourceDependency(dependsOnPath: Path, sourcePath: Path): Unit
|
||||
/** Called to indicate that the source file <code>sourcePath</code> depends on the jar
|
||||
* <code>jarPath</code>.*/
|
||||
def jarDependency(jarPath: File, sourcePath: Path): Unit
|
||||
/** Called to indicate that the source file <code>sourcePath</code> depends on the class file
|
||||
* <code>classFile</code>.*/
|
||||
def classDependency(classFile: File, sourcePath: Path): Unit
|
||||
/** Called to indicate that the source file <code>sourcePath</code> produces a class file at
|
||||
* <code>modulePath</code>.*/
|
||||
def generatedClass(sourcePath: Path, modulePath: Path): Unit
|
||||
/** Called after the source at the given location has been processed. */
|
||||
def endSource(sourcePath: Path): Unit
|
||||
/** Called when a module with a public 'main' method with the right signature is found.*/
|
||||
def foundApplication(sourcePath: Path, className: String): Unit
|
||||
}
|
||||
abstract class BasicAnalysisCallback[A <: BasicCompileAnalysis](val basePath: Path, val superclassNames: Iterable[String],
|
||||
protected val analysis: A) extends AnalysisCallback
|
||||
{
|
||||
def superclassNotFound(superclassName: String) {}
|
||||
|
||||
def beginSource(sourcePath: Path)
|
||||
{
|
||||
analysis.addSource(sourcePath)
|
||||
}
|
||||
def sourceDependency(dependsOnPath: Path, sourcePath: Path)
|
||||
{
|
||||
analysis.addSourceDependency(dependsOnPath, sourcePath)
|
||||
}
|
||||
def jarDependency(jarFile: File, sourcePath: Path)
|
||||
{
|
||||
analysis.addExternalDependency(jarFile, sourcePath)
|
||||
}
|
||||
def classDependency(classFile: File, sourcePath: Path)
|
||||
{
|
||||
analysis.addExternalDependency(classFile, sourcePath)
|
||||
}
|
||||
def generatedClass(sourcePath: Path, modulePath: Path)
|
||||
{
|
||||
analysis.addProduct(sourcePath, modulePath)
|
||||
}
|
||||
def endSource(sourcePath: Path)
|
||||
{
|
||||
analysis.removeSelfDependency(sourcePath)
|
||||
}
|
||||
}
|
||||
abstract class BasicCompileAnalysisCallback(basePath: Path, superclassNames: Iterable[String], analysis: CompileAnalysis)
|
||||
extends BasicAnalysisCallback(basePath, superclassNames, analysis)
|
||||
{
|
||||
def foundApplication(sourcePath: Path, className: String)
|
||||
{
|
||||
analysis.addApplication(sourcePath, className)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,234 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import scala.tools.nsc.{io, plugins, symtab, Global, Phase}
|
||||
import io.{AbstractFile, PlainFile, ZipArchive}
|
||||
import plugins.{Plugin, PluginComponent}
|
||||
import symtab.Flags
|
||||
import scala.collection.mutable.{HashMap, HashSet, Map, Set}
|
||||
|
||||
import java.io.File
|
||||
|
||||
object Analyzer
|
||||
{
|
||||
val PluginName = "sbt-analyzer"
|
||||
val CallbackIDOptionName = "callback:"
|
||||
}
|
||||
class Analyzer(val global: Global) extends Plugin
|
||||
{
|
||||
import global._
|
||||
import Analyzer._
|
||||
|
||||
val name = PluginName
|
||||
val description = "A plugin to find all concrete instances of a given class and extract dependency information."
|
||||
val components = List[PluginComponent](Component)
|
||||
|
||||
private var callbackOption: Option[AnalysisCallback] = None
|
||||
|
||||
override def processOptions(options: List[String], error: String => Unit)
|
||||
{
|
||||
for(option <- options)
|
||||
{
|
||||
if(option.startsWith(CallbackIDOptionName))
|
||||
callbackOption = AnalysisCallback(option.substring(CallbackIDOptionName.length).toInt)
|
||||
else
|
||||
error("Option for sbt analyzer plugin not understood: " + option)
|
||||
}
|
||||
if(callbackOption.isEmpty)
|
||||
error("Callback ID not specified for sbt analyzer plugin.")
|
||||
}
|
||||
|
||||
override val optionsHelp: Option[String] =
|
||||
{
|
||||
val prefix = " -P:" + name + ":"
|
||||
Some(prefix + CallbackIDOptionName + "<callback-id> Set the callback id.\n")
|
||||
}
|
||||
|
||||
/* ================================================== */
|
||||
// These two templates abuse scope for source compatibility between Scala 2.7.x and 2.8.x so that a single
|
||||
// sbt codebase compiles with both series of versions.
|
||||
// In 2.8.x, PluginComponent.runsAfter has type List[String] and the method runsBefore is defined on
|
||||
// PluginComponent with default value Nil.
|
||||
// In 2.7.x, runsBefore does not exist on PluginComponent and PluginComponent.runsAfter has type String.
|
||||
//
|
||||
// Therefore, in 2.8.x, object runsBefore is shadowed by PluginComponent.runsBefore (which is Nil) and so
|
||||
// afterPhase :: runsBefore
|
||||
// is equivalent to List[String](afterPhase)
|
||||
// In 2.7.x, object runsBefore is not shadowed and so runsAfter has type String.
|
||||
private object runsBefore { def :: (s: String) = s }
|
||||
private abstract class CompatiblePluginComponent(afterPhase: String) extends PluginComponent
|
||||
{
|
||||
override val runsAfter = afterPhase :: runsBefore
|
||||
}
|
||||
/* ================================================== */
|
||||
|
||||
private object Component extends CompatiblePluginComponent("jvm")
|
||||
{
|
||||
val global = Analyzer.this.global
|
||||
val phaseName = Analyzer.this.name
|
||||
def newPhase(prev: Phase) = new AnalyzerPhase(prev)
|
||||
}
|
||||
|
||||
private class AnalyzerPhase(prev: Phase) extends Phase(prev)
|
||||
{
|
||||
def name = Analyzer.this.name
|
||||
def run
|
||||
{
|
||||
val callback = callbackOption.get
|
||||
val projectPath = callback.basePath
|
||||
val projectPathString = Path.basePathString(projectPath).getOrElse({error("Could not determine base path for " + projectPath); ""})
|
||||
def relativize(file: File) = Path.relativize(projectPath, projectPathString, file)
|
||||
|
||||
val outputDir = new File(global.settings.outdir.value)
|
||||
val outputPathOption = relativize(outputDir)
|
||||
if(outputPathOption.isEmpty)
|
||||
error("Output directory " + outputDir.getAbsolutePath + " must be in the project directory.")
|
||||
val outputPath = outputPathOption.get
|
||||
|
||||
val superclassNames = callback.superclassNames.map(newTermName)
|
||||
val superclassesAll =
|
||||
for(name <- superclassNames) yield
|
||||
{
|
||||
try { Some(global.definitions.getClass(name)) }
|
||||
catch { case fe: scala.tools.nsc.FatalError => callback.superclassNotFound(name.toString); None }
|
||||
}
|
||||
val superclasses = superclassesAll.filter(_.isDefined).map(_.get)
|
||||
|
||||
for(unit <- currentRun.units)
|
||||
{
|
||||
// build dependencies structure
|
||||
val sourceFile = unit.source.file.file
|
||||
val sourcePathOption = relativize(sourceFile)
|
||||
if(sourcePathOption.isEmpty)
|
||||
error("Source file " + sourceFile.getAbsolutePath + " must be in the project directory.")
|
||||
val sourcePath = sourcePathOption.get
|
||||
callback.beginSource(sourcePath)
|
||||
for(on <- unit.depends)
|
||||
{
|
||||
val onSource = on.sourceFile
|
||||
if(onSource == null)
|
||||
{
|
||||
classFile(on) match
|
||||
{
|
||||
case Some(f) =>
|
||||
{
|
||||
f match
|
||||
{
|
||||
case ze: ZipArchive#Entry => callback.jarDependency(new File(ze.getArchive.getName), sourcePath)
|
||||
case pf: PlainFile =>
|
||||
{
|
||||
// ignore dependencies in the output directory: these are handled by source dependencies
|
||||
if(Path.relativize(outputPath, pf.file).isEmpty)
|
||||
callback.classDependency(pf.file, sourcePath)
|
||||
}
|
||||
case _ => ()
|
||||
}
|
||||
}
|
||||
case None => ()
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(depPath <- relativize(onSource.file))
|
||||
callback.sourceDependency(depPath, sourcePath)
|
||||
}
|
||||
}
|
||||
|
||||
// find subclasses and modules with main methods
|
||||
for(clazz @ ClassDef(mods, n, _, _) <- unit.body)
|
||||
{
|
||||
val sym = clazz.symbol
|
||||
if(sym != NoSymbol && mods.isPublic && !mods.isAbstract && !mods.isTrait &&
|
||||
!sym.isImplClass && sym.isStatic && !sym.isNestedClass)
|
||||
{
|
||||
val isModule = sym.isModuleClass
|
||||
for(superclass <- superclasses.filter(sym.isSubClass))
|
||||
callback.foundSubclass(sourcePath, sym.fullNameString, superclass.fullNameString, isModule)
|
||||
if(isModule && hasMainMethod(sym))
|
||||
callback.foundApplication(sourcePath, sym.fullNameString)
|
||||
}
|
||||
}
|
||||
|
||||
// build list of generated classes
|
||||
for(iclass <- unit.icode)
|
||||
{
|
||||
val sym = iclass.symbol
|
||||
def addGenerated(separatorRequired: Boolean)
|
||||
{
|
||||
val classPath = pathOfClass(outputPath, sym, separatorRequired)
|
||||
if(classPath.asFile.exists)
|
||||
callback.generatedClass(sourcePath, classPath)
|
||||
}
|
||||
if(sym.isModuleClass && !sym.isImplClass)
|
||||
{
|
||||
if(isTopLevelModule(sym) && sym.linkedClassOfModule == NoSymbol)
|
||||
addGenerated(false)
|
||||
addGenerated(true)
|
||||
}
|
||||
else
|
||||
addGenerated(false)
|
||||
}
|
||||
callback.endSource(sourcePath)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private def classFile(sym: Symbol): Option[AbstractFile] =
|
||||
{
|
||||
import scala.tools.nsc.symtab.Flags
|
||||
val name = sym.fullNameString(java.io.File.separatorChar) + (if (sym.hasFlag(Flags.MODULE)) "$" else "")
|
||||
val entry = classPath.root.find(name, false)
|
||||
if (entry ne null)
|
||||
Some(entry.classFile)
|
||||
else
|
||||
None
|
||||
}
|
||||
|
||||
private def isTopLevelModule(sym: Symbol): Boolean =
|
||||
atPhase (currentRun.picklerPhase.next) {
|
||||
sym.isModuleClass && !sym.isImplClass && !sym.isNestedClass
|
||||
}
|
||||
private def pathOfClass(outputPath: Path, s: Symbol, separatorRequired: Boolean): Path =
|
||||
pathOfClass(outputPath, s, separatorRequired, ".class")
|
||||
private def pathOfClass(outputPath: Path, s: Symbol, separatorRequired: Boolean, postfix: String): Path =
|
||||
{
|
||||
if(s.owner.isPackageClass && s.isPackageClass)
|
||||
packagePath(outputPath, s) / postfix
|
||||
else
|
||||
pathOfClass(outputPath, s.owner.enclClass, true, s.simpleName + (if(separatorRequired) "$" else "") + postfix)
|
||||
}
|
||||
private def packagePath(outputPath: Path, s: Symbol): Path =
|
||||
{
|
||||
if(s.isEmptyPackageClass || s.isRoot)
|
||||
outputPath
|
||||
else
|
||||
packagePath(outputPath, s.owner.enclClass) / s.simpleName.toString
|
||||
}
|
||||
|
||||
private def hasMainMethod(sym: Symbol): Boolean =
|
||||
{
|
||||
val main = sym.info.nonPrivateMember(newTermName("main"))//nme.main)
|
||||
main.tpe match
|
||||
{
|
||||
case OverloadedType(pre, alternatives) => alternatives.exists(alt => isVisible(alt) && isMainType(pre.memberType(alt)))
|
||||
case tpe => isVisible(main) && isMainType(main.owner.thisType.memberType(main))
|
||||
}
|
||||
}
|
||||
private def isVisible(sym: Symbol) = sym != NoSymbol && sym.isPublic && !sym.isDeferred
|
||||
private def isMainType(tpe: Type) =
|
||||
{
|
||||
tpe match
|
||||
{
|
||||
// singleArgument is of type Symbol in 2.8.0 and type Type in 2.7.x
|
||||
case MethodType(List(singleArgument), result) => isUnitType(result) && isStringArray(singleArgument)
|
||||
case _ => false
|
||||
}
|
||||
}
|
||||
private lazy val StringArrayType = appliedType(definitions.ArrayClass.typeConstructor, definitions.StringClass.tpe :: Nil)
|
||||
// isStringArray is overloaded to handle the incompatibility between 2.7.x and 2.8.0
|
||||
private def isStringArray(tpe: Type): Boolean = tpe.typeSymbol == StringArrayType.typeSymbol
|
||||
private def isStringArray(sym: Symbol): Boolean = isStringArray(sym.tpe)
|
||||
private def isUnitType(tpe: Type) = tpe.typeSymbol == definitions.UnitClass
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
trait AutoCompilerPlugins extends BasicScalaProject
|
||||
{
|
||||
import Configurations.CompilerPlugin
|
||||
abstract override def ivyConfigurations =
|
||||
{
|
||||
val superConfigurations = super.ivyConfigurations.toList
|
||||
val newConfigurations =
|
||||
if(superConfigurations.isEmpty)
|
||||
{
|
||||
if(useDefaultConfigurations)
|
||||
CompilerPlugin :: Configurations.defaultMavenConfigurations
|
||||
else
|
||||
Configurations.Default :: CompilerPlugin :: Nil
|
||||
}
|
||||
else
|
||||
CompilerPlugin :: superConfigurations
|
||||
log.debug("Auto configurations: " + newConfigurations.toList.mkString(", "))
|
||||
Configurations.removeDuplicates(newConfigurations)
|
||||
}
|
||||
abstract override def compileOptions = compilerPlugins ++ super.compileOptions
|
||||
|
||||
/** A PathFinder that provides the classpath to search for compiler plugins. */
|
||||
def pluginClasspath = fullClasspath(CompilerPlugin)
|
||||
protected def compilerPlugins: List[CompileOption] =
|
||||
ClasspathUtilities.compilerPlugins(pluginClasspath.get).map(plugin => new CompileOption("-Xplugin:" + plugin.getAbsolutePath)).toList
|
||||
|
||||
def compilerPlugin(dependency: ModuleID) = dependency % "plugin->default(compile)"
|
||||
}
|
||||
|
|
@ -0,0 +1,578 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import StringUtilities.{appendable,nonEmpty}
|
||||
|
||||
/** A project that provides a classpath. */
|
||||
trait ClasspathProject extends Project
|
||||
{
|
||||
/** The local classpath for this project.*/
|
||||
def projectClasspath(config: Configuration): PathFinder
|
||||
|
||||
/** Returns the classpath of this project and the classpaths of all dependencies for the
|
||||
* given configuration. Specifically, this concatentates projectClasspath(config) for all
|
||||
* projects of type ClasspathProject in topologicalSort. */
|
||||
def fullClasspath(config: Configuration): PathFinder =
|
||||
Path.lazyPathFinder
|
||||
{
|
||||
val set = new wrap.MutableSetWrapper(new java.util.LinkedHashSet[Path])
|
||||
for(project <- topologicalSort)
|
||||
{
|
||||
project match
|
||||
{
|
||||
case sp: ClasspathProject => set ++= sp.projectClasspath(config).get
|
||||
case _ => ()
|
||||
}
|
||||
}
|
||||
set.toList
|
||||
}
|
||||
}
|
||||
trait BasicDependencyProject extends BasicManagedProject with UnmanagedClasspathProject
|
||||
{
|
||||
/** This returns the classpath for only this project for the given configuration.*/
|
||||
def projectClasspath(config: Configuration) = fullUnmanagedClasspath(config) +++ managedClasspath(config)
|
||||
}
|
||||
/** A project that provides a directory in which jars can be manually managed.*/
|
||||
trait UnmanagedClasspathProject extends ClasspathProject
|
||||
{
|
||||
/** The location of the manually managed (unmanaged) dependency directory.*/
|
||||
def dependencyPath: Path
|
||||
/** The classpath containing all jars in the unmanaged directory. */
|
||||
def unmanagedClasspath: PathFinder =
|
||||
{
|
||||
val base = descendents(dependencyPath, "*.jar")
|
||||
if(scratch)
|
||||
base +++ (info.projectPath * "*.jar")
|
||||
else
|
||||
base
|
||||
}
|
||||
/** The classpath containing all unmanaged classpath elements for the given configuration. This typically includes
|
||||
* at least 'unmanagedClasspath'.*/
|
||||
def fullUnmanagedClasspath(config: Configuration): PathFinder
|
||||
}
|
||||
|
||||
/** A project that provides automatic dependency management.*/
|
||||
trait ManagedProject extends ClasspathProject
|
||||
{
|
||||
trait ManagedOption extends ActionOption
|
||||
final class ManagedFlagOption extends ManagedOption
|
||||
/** An update option that specifies that unneeded files should be pruned from the managed library directory
|
||||
* after updating. */
|
||||
final val Synchronize = new ManagedFlagOption
|
||||
/** An update option that specifies that Ivy should validate configurations.*/
|
||||
final val Validate = new ManagedFlagOption
|
||||
/** An update option that puts Ivy into a quieter logging mode.*/
|
||||
final val QuietUpdate = new ManagedFlagOption
|
||||
/** An update option that adds the scala-tools.org releases repository to the set of resolvers, unless
|
||||
* no inline repositories are present and an ivysettings.xml file is present.*/
|
||||
final val AddScalaToolsReleases = new ManagedFlagOption
|
||||
/** An update option that specifies that an error should be generated if no inline dependencies, resolvers,
|
||||
* XML file, or Ivy or Maven configuration files are present.*/
|
||||
final val ErrorIfNoConfiguration = new ManagedFlagOption
|
||||
/** An update option that explicitly specifies the dependency manager to use. This can be used to
|
||||
* override the default precendence. */
|
||||
final case class LibraryManager(m: Manager) extends ManagedOption
|
||||
/** An update option that overrides the default Ivy cache location. */
|
||||
final case class CacheDirectory(dir: Path) extends ManagedOption
|
||||
final case class CheckScalaVersion(configs: Iterable[Configuration], checkExplicit: Boolean, filterImplicit: Boolean) extends ManagedOption
|
||||
|
||||
private def withConfigurations(outputPattern: String, managedDependencyPath: Path, options: Seq[ManagedOption])
|
||||
(doWith: (IvyConfiguration, UpdateConfiguration) => Option[String]) =
|
||||
{
|
||||
var synchronize = false
|
||||
var validate = false
|
||||
var quiet = false
|
||||
var addScalaTools = false
|
||||
var errorIfNoConfiguration = false
|
||||
var manager: Manager = new AutoDetectManager(projectID)
|
||||
var cacheDirectory: Option[Path] = None
|
||||
var checkScalaVersion: Option[IvyScala] = None
|
||||
for(option <- options)
|
||||
{
|
||||
option match
|
||||
{
|
||||
case Synchronize => synchronize = true
|
||||
case Validate => validate = true
|
||||
case LibraryManager(m) => manager = m
|
||||
case QuietUpdate => quiet = true
|
||||
case AddScalaToolsReleases => addScalaTools = true
|
||||
case ErrorIfNoConfiguration => errorIfNoConfiguration = true
|
||||
case CacheDirectory(dir) => cacheDirectory = Some(dir)
|
||||
case CheckScalaVersion(configs, checkExplicit, filterImplicit) =>
|
||||
checkScalaVersion = getScalaVersion.map(version => new IvyScala(version, configs, checkExplicit, filterImplicit))
|
||||
case _ => log.warn("Ignored unknown managed option " + option)
|
||||
}
|
||||
}
|
||||
val ivyPaths = new IvyPaths(info.projectPath, managedDependencyPath, cacheDirectory)
|
||||
val ivyFlags = new IvyFlags(validate, addScalaTools, errorIfNoConfiguration)
|
||||
val ivyConfiguration = new IvyConfiguration(ivyPaths, manager, ivyFlags, checkScalaVersion, log)
|
||||
val updateConfiguration = new UpdateConfiguration(outputPattern, synchronize, quiet)
|
||||
doWith(ivyConfiguration, updateConfiguration)
|
||||
}
|
||||
private def getScalaVersion =
|
||||
{
|
||||
val v = scalaVersion.value
|
||||
if(v.isEmpty) None
|
||||
else Some(v)
|
||||
}
|
||||
private def withIvyTask(doTask: => Option[String]) =
|
||||
task
|
||||
{
|
||||
try { doTask }
|
||||
catch
|
||||
{
|
||||
case e: NoClassDefFoundError =>
|
||||
log.trace(e)
|
||||
Some("Apache Ivy is required for dependency management (" + e.toString + ")")
|
||||
}
|
||||
}
|
||||
def updateTask(outputPattern: String, managedDependencyPath: Path, options: ManagedOption*): Task =
|
||||
updateTask(outputPattern, managedDependencyPath, options)
|
||||
def updateTask(outputPattern: String, managedDependencyPath: Path, options: => Seq[ManagedOption]) =
|
||||
withIvyTask(withConfigurations(outputPattern, managedDependencyPath, options)(ManageDependencies.update))
|
||||
|
||||
def publishTask(publishConfiguration: => PublishConfiguration, options: => Seq[ManagedOption]) =
|
||||
withIvyTask
|
||||
{
|
||||
val publishConfig = publishConfiguration
|
||||
import publishConfig._
|
||||
withConfigurations("", managedDependencyPath, options) { (ivyConf, ignore) =>
|
||||
val delivered = if(publishIvy) Some(deliveredPattern) else None
|
||||
ManageDependencies.publish(ivyConf, resolverName, srcArtifactPatterns, delivered, configurations) }
|
||||
}
|
||||
def deliverTask(deliverConfiguration: => PublishConfiguration, options: => Seq[ManagedOption]) =
|
||||
withIvyTask
|
||||
{
|
||||
val deliverConfig = deliverConfiguration
|
||||
import deliverConfig._
|
||||
withConfigurations("", managedDependencyPath, options) { (ivyConf, updateConf) =>
|
||||
ManageDependencies.deliver(ivyConf, updateConf, status, deliveredPattern, extraDependencies, configurations)
|
||||
}
|
||||
}
|
||||
def makePomTask(output: => Path, extraDependencies: => Iterable[ModuleID], configurations: => Option[Iterable[Configuration]], options: => Seq[ManagedOption]) =
|
||||
withIvyTask(withConfigurations("", managedDependencyPath, options) { (ivyConf, ignore) =>
|
||||
ManageDependencies.makePom(ivyConf, extraDependencies, configurations, output.asFile) })
|
||||
|
||||
def cleanCacheTask(managedDependencyPath: Path, options: => Seq[ManagedOption]) =
|
||||
withIvyTask(withConfigurations("", managedDependencyPath, options) { (ivyConf, ignore) => ManageDependencies.cleanCache(ivyConf) })
|
||||
|
||||
def cleanLibTask(managedDependencyPath: Path) = task { FileUtilities.clean(managedDependencyPath.get, log) }
|
||||
|
||||
/** This is the public ID of the project (used for publishing, for example) */
|
||||
def moduleID: String = normalizedName + appendable(crossScalaVersionString)
|
||||
/** This is the full public ID of the project (used for publishing, for example) */
|
||||
def projectID: ModuleID = ModuleID(organization, moduleID, version.toString)
|
||||
|
||||
/** This is the default name for artifacts (such as jars) without any version string.*/
|
||||
def artifactID = moduleID
|
||||
/** This is the default name for artifacts (such as jars) including the version string.*/
|
||||
def artifactBaseName = artifactID + "-" + version.toString
|
||||
def artifacts: Iterable[Artifact]
|
||||
|
||||
def managedDependencyPath: Path
|
||||
/** The managed classpath for the given configuration. This can be overridden to add jars from other configurations
|
||||
* so that the Ivy 'extends' mechanism is not required. That way, the jars are only copied to one configuration.*/
|
||||
def managedClasspath(config: Configuration): PathFinder = configurationClasspath(config)
|
||||
/** All dependencies in the given configuration. */
|
||||
final def configurationClasspath(config: Configuration): PathFinder = descendents(configurationPath(config), "*.jar")
|
||||
/** The base path to which dependencies in configuration 'config' are downloaded.*/
|
||||
def configurationPath(config: Configuration): Path = managedDependencyPath / config.toString
|
||||
|
||||
import StringUtilities.nonEmpty
|
||||
implicit def toGroupID(groupID: String): GroupID =
|
||||
{
|
||||
nonEmpty(groupID, "Group ID")
|
||||
new GroupID(groupID, ScalaVersion.currentString)
|
||||
}
|
||||
implicit def toRepositoryName(name: String): RepositoryName =
|
||||
{
|
||||
nonEmpty(name, "Repository name")
|
||||
new RepositoryName(name)
|
||||
}
|
||||
implicit def moduleIDConfigurable(m: ModuleID): ModuleIDConfigurable =
|
||||
{
|
||||
require(m.configurations.isEmpty, "Configurations already specified for module " + m)
|
||||
new ModuleIDConfigurable(m)
|
||||
}
|
||||
|
||||
/** Creates a new configuration with the given name.*/
|
||||
def config(name: String) = new Configuration(name)
|
||||
}
|
||||
/** This class groups required configuration for the deliver and publish tasks. */
|
||||
trait PublishConfiguration extends NotNull
|
||||
{
|
||||
/** The name of the resolver to which publishing should be done.*/
|
||||
def resolverName: String
|
||||
/** The Ivy pattern used to determine the delivered Ivy file location. An example is
|
||||
* (outputPath / "[artifact]-[revision].[ext]").relativePath. */
|
||||
def deliveredPattern: String
|
||||
/** Ivy patterns used to find artifacts for publishing. An example pattern is
|
||||
* (outputPath / "[artifact]-[revision].[ext]").relativePath */
|
||||
def srcArtifactPatterns: Iterable[String]
|
||||
/** Additional dependencies to include for delivering/publishing only. These are typically dependencies on
|
||||
* subprojects. */
|
||||
def extraDependencies: Iterable[ModuleID]
|
||||
/** The status to use when delivering or publishing. This might be "release" or "integration" or another valid Ivy status. */
|
||||
def status: String
|
||||
/** The configurations to include in the publish/deliver action: specify none for all configurations. */
|
||||
def configurations: Option[Iterable[Configuration]]
|
||||
/** True if the Ivy file should be published. */
|
||||
def publishIvy: Boolean
|
||||
}
|
||||
object ManagedStyle extends Enumeration
|
||||
{
|
||||
val Maven, Ivy = Value
|
||||
}
|
||||
import ManagedStyle.{Ivy, Maven, Value => ManagedType}
|
||||
trait BasicManagedProject extends ManagedProject with ReflectiveManagedProject with BasicDependencyPaths
|
||||
{
|
||||
import BasicManagedProject._
|
||||
/** The dependency manager that represents inline declarations. The default manager packages the information
|
||||
* from 'ivyXML', 'projectID', 'repositories', and 'libraryDependencies' and does not typically need to be
|
||||
* be overridden. */
|
||||
def manager = new SimpleManager(ivyXML, true, projectID, repositories, ivyConfigurations, defaultConfiguration, artifacts, libraryDependencies.toList: _*)
|
||||
|
||||
/** The pattern for Ivy to use when retrieving dependencies into the local project. Classpath management
|
||||
* depends on the first directory being [conf] and the extension being [ext].*/
|
||||
def outputPattern = "[conf]/[artifact](-[revision]).[ext]"
|
||||
/** Override this to specify the publications, configurations, and/or dependencies sections of an Ivy file.
|
||||
* See http://code.google.com/p/simple-build-tool/wiki/LibraryManagement for details.*/
|
||||
def ivyXML: scala.xml.NodeSeq = scala.xml.NodeSeq.Empty
|
||||
/** The base options passed to the 'update' action. */
|
||||
def baseUpdateOptions = checkScalaVersion :: Validate :: Synchronize :: QuietUpdate :: AddScalaToolsReleases :: Nil
|
||||
override def ivyConfigurations: Iterable[Configuration] =
|
||||
{
|
||||
val reflective = super.ivyConfigurations
|
||||
if(useDefaultConfigurations)
|
||||
{
|
||||
if(reflective.isEmpty && !useIntegrationTestConfiguration)
|
||||
Nil
|
||||
else
|
||||
{
|
||||
val base = Configurations.defaultMavenConfigurations ++ reflective
|
||||
val allConfigurations =
|
||||
if(useIntegrationTestConfiguration)
|
||||
base ++ List(Configurations.IntegrationTest)
|
||||
else
|
||||
base
|
||||
Configurations.removeDuplicates(allConfigurations)
|
||||
}
|
||||
}
|
||||
else
|
||||
reflective
|
||||
}
|
||||
def useIntegrationTestConfiguration = false
|
||||
def defaultConfiguration: Option[Configuration] = Some(Configurations.DefaultConfiguration(useDefaultConfigurations))
|
||||
def useMavenConfigurations = true // TBD: set to true and deprecate
|
||||
def useDefaultConfigurations = useMavenConfigurations
|
||||
def managedStyle: ManagedType = Maven
|
||||
protected implicit final val defaultPatterns: RepositoryHelpers.Patterns =
|
||||
{
|
||||
managedStyle match
|
||||
{
|
||||
case Maven => Resolver.mavenStylePatterns
|
||||
case Ivy => Resolver.ivyStylePatterns
|
||||
}
|
||||
}
|
||||
/** The options provided to the 'update' action. This is by default the options in 'baseUpdateOptions'.
|
||||
* If 'manager' has any dependencies, resolvers, or inline Ivy XML (which by default happens when inline
|
||||
* dependency management is used), it is passed as the dependency manager.*/
|
||||
def updateOptions: Seq[ManagedOption] =
|
||||
{
|
||||
val m = manager
|
||||
if(m.dependencies.isEmpty && m.resolvers.isEmpty && ivyXML.isEmpty && m.artifacts.isEmpty && m.configurations.isEmpty)
|
||||
baseUpdateOptions
|
||||
else
|
||||
LibraryManager(m) :: baseUpdateOptions
|
||||
}
|
||||
def deliverOptions: Seq[ManagedOption] = updateOptions.filter { case _: CheckScalaVersion => false; case _ => true }
|
||||
def publishOptions: Seq[ManagedOption] = deliverOptions
|
||||
/** True if the 'provided' configuration should be included on the 'compile' classpath. The default value is true.*/
|
||||
def includeProvidedWithCompile = true
|
||||
/** True if the default implicit extensions should be used when determining classpaths. The default value is true. */
|
||||
def defaultConfigurationExtensions = true
|
||||
/** If true, verify that explicit dependencies on Scala libraries use the same version as scala.version. */
|
||||
def checkExplicitScalaDependencies = true
|
||||
/** If true, filter dependencies on scala-library and scala-compiler. This is true by default to avoid conflicts with
|
||||
* the jars provided by sbt. You can set this to false to download these jars. Overriding checkScalaInConfigurations might
|
||||
* be more appropriate, however.*/
|
||||
def filterScalaJars = true
|
||||
/** The configurations to check/filter.*/
|
||||
def checkScalaInConfigurations: Iterable[Configuration] =
|
||||
{
|
||||
val all = ivyConfigurations
|
||||
if(all.isEmpty)
|
||||
Configurations.defaultMavenConfigurations
|
||||
else
|
||||
all
|
||||
}
|
||||
def checkScalaVersion = CheckScalaVersion(checkScalaInConfigurations, checkExplicitScalaDependencies, filterScalaJars)
|
||||
def defaultPublishRepository: Option[Resolver] =
|
||||
{
|
||||
reflectiveRepositories.get("publish-to") orElse
|
||||
info.parent.flatMap
|
||||
{
|
||||
case managed: BasicManagedProject => managed.defaultPublishRepository
|
||||
case _ => None
|
||||
}
|
||||
}
|
||||
/** Includes the Provided configuration on the Compile classpath, the Compile configuration on the Runtime classpath,
|
||||
* and Compile and Runtime on the Test classpath. Including Provided can be disabled by setting
|
||||
* includeProvidedWithCompile to false. Including Compile and Runtime can be disabled by setting
|
||||
* defaultConfigurationExtensions to false.*/
|
||||
override def managedClasspath(config: Configuration) =
|
||||
{
|
||||
import Configurations.{Compile, CompilerPlugin, Default, Provided, Runtime, Test}
|
||||
val baseClasspath = configurationClasspath(config)
|
||||
config match
|
||||
{
|
||||
case Compile =>
|
||||
val baseCompileClasspath = baseClasspath +++ managedClasspath(Default)
|
||||
if(includeProvidedWithCompile)
|
||||
baseCompileClasspath +++ managedClasspath(Provided)
|
||||
else
|
||||
baseCompileClasspath
|
||||
case Runtime if defaultConfigurationExtensions => baseClasspath +++ managedClasspath(Compile)
|
||||
case Test if defaultConfigurationExtensions => baseClasspath +++ managedClasspath(Runtime)
|
||||
case _ => baseClasspath
|
||||
}
|
||||
}
|
||||
|
||||
protected def updateAction = updateTask(outputPattern, managedDependencyPath, updateOptions) describedAs UpdateDescription
|
||||
protected def cleanLibAction = cleanLibTask(managedDependencyPath) describedAs CleanLibDescription
|
||||
protected def cleanCacheAction = cleanCacheTask(managedDependencyPath, updateOptions) describedAs CleanCacheDescription
|
||||
|
||||
protected def deliverProjectDependencies: Iterable[ModuleID] =
|
||||
{
|
||||
val interDependencies = new scala.collection.mutable.ListBuffer[ModuleID]
|
||||
dependencies.foreach(dep => dep match { case mp: ManagedProject => interDependencies += mp.projectID; case _ => () })
|
||||
if(filterScalaJars)
|
||||
interDependencies ++= deliverScalaDependencies
|
||||
interDependencies.readOnly
|
||||
}
|
||||
protected def deliverScalaDependencies: Iterable[ModuleID] = Nil
|
||||
protected def makePomAction = makePomTask(pomPath, deliverProjectDependencies, None, updateOptions)
|
||||
protected def deliverLocalAction = deliverTask(publishLocalConfiguration, deliverOptions)
|
||||
protected def publishLocalAction =
|
||||
{
|
||||
val dependencies = deliverLocal :: publishPomDepends
|
||||
publishTask(publishLocalConfiguration, publishOptions) dependsOn(dependencies : _*)
|
||||
}
|
||||
protected def publishLocalConfiguration = new DefaultPublishConfiguration("local", "release", true)
|
||||
protected def deliverAction = deliverTask(publishConfiguration, deliverOptions)
|
||||
protected def publishAction =
|
||||
{
|
||||
val dependencies = deliver :: publishPomDepends
|
||||
publishTask(publishConfiguration, publishOptions) dependsOn(dependencies : _*)
|
||||
}
|
||||
private def publishPomDepends = if(managedStyle == Maven) makePom :: Nil else Nil
|
||||
protected def publishConfiguration =
|
||||
{
|
||||
val repository = defaultPublishRepository.getOrElse(error("Repository to publish to not specified."))
|
||||
val publishIvy = managedStyle != Maven
|
||||
new DefaultPublishConfiguration(repository, "release", publishIvy)
|
||||
}
|
||||
protected class DefaultPublishConfiguration(val resolverName: String, val status: String, val publishIvy: Boolean) extends PublishConfiguration
|
||||
{
|
||||
def this(resolver: Resolver, status: String, publishIvy: Boolean) = this(resolver.name, status, publishIvy)
|
||||
def this(resolverName: String, status: String) = this(resolverName, status, true)
|
||||
def this(resolver: Resolver, status: String) = this(resolver.name, status)
|
||||
|
||||
protected def deliveredPathPattern = outputPath / "[artifact]-[revision].[ext]"
|
||||
def deliveredPattern = deliveredPathPattern.relativePath
|
||||
def srcArtifactPatterns: Iterable[String] =
|
||||
{
|
||||
val pathPatterns =
|
||||
(outputPath / "[artifact]-[revision]-[type].[ext]") ::
|
||||
(outputPath / "[artifact]-[revision].[ext]") ::
|
||||
Nil
|
||||
pathPatterns.map(_.relativePath)
|
||||
}
|
||||
def extraDependencies: Iterable[ModuleID] = Nil//deliverProjectDependencies
|
||||
/** The configurations to include in the publish/deliver action: specify none for all public configurations. */
|
||||
def configurations: Option[Iterable[Configuration]] = None
|
||||
}
|
||||
|
||||
lazy val update = updateAction
|
||||
lazy val makePom = makePomAction
|
||||
lazy val deliverLocal = deliverLocalAction
|
||||
lazy val publishLocal = publishLocalAction
|
||||
lazy val deliver = deliverAction
|
||||
lazy val publish = publishAction
|
||||
lazy val cleanLib = cleanLibAction
|
||||
lazy val cleanCache = cleanCacheAction
|
||||
}
|
||||
|
||||
object BasicManagedProject
|
||||
{
|
||||
val UpdateDescription =
|
||||
"Resolves and retrieves automatically managed dependencies."
|
||||
val CleanLibDescription =
|
||||
"Deletes the managed library directory."
|
||||
val CleanCacheDescription =
|
||||
"Deletes the cache of artifacts downloaded for automatically managed dependencies."
|
||||
}
|
||||
|
||||
trait BasicDependencyPaths extends ManagedProject
|
||||
{
|
||||
import BasicDependencyPaths._
|
||||
def dependencyDirectoryName = DefaultDependencyDirectoryName
|
||||
def managedDirectoryName = DefaultManagedDirectoryName
|
||||
def pomName = artifactBaseName + PomExtension
|
||||
def dependencyPath = path(dependencyDirectoryName)
|
||||
def managedDependencyPath = crossPath(managedDependencyRootPath)
|
||||
def managedDependencyRootPath: Path = managedDirectoryName
|
||||
def pomPath = outputPath / pomName
|
||||
}
|
||||
object BasicDependencyPaths
|
||||
{
|
||||
val DefaultManagedDirectoryName = "lib_managed"
|
||||
val DefaultManagedSourceDirectoryName = "src_managed"
|
||||
val DefaultDependencyDirectoryName = "lib"
|
||||
val PomExtension = ".pom"
|
||||
}
|
||||
|
||||
object StringUtilities
|
||||
{
|
||||
def normalize(s: String) = s.toLowerCase.replaceAll("""\s+""", "-")
|
||||
def nonEmpty(s: String, label: String)
|
||||
{
|
||||
require(s.trim.length > 0, label + " cannot be empty.")
|
||||
}
|
||||
def appendable(s: String) = if(s.isEmpty) "" else "_" + s
|
||||
}
|
||||
final class GroupID private[sbt] (groupID: String, scalaVersion: String) extends NotNull
|
||||
{
|
||||
def % (artifactID: String) = groupArtifact(artifactID)
|
||||
def %% (artifactID: String) =
|
||||
{
|
||||
require(!scalaVersion.isEmpty, "Cannot use %% when the sbt launcher is not used.")
|
||||
groupArtifact(artifactID + appendable(scalaVersion))
|
||||
}
|
||||
private def groupArtifact(artifactID: String) =
|
||||
{
|
||||
nonEmpty(artifactID, "Artifact ID")
|
||||
new GroupArtifactID(groupID, artifactID)
|
||||
}
|
||||
}
|
||||
final class GroupArtifactID private[sbt] (groupID: String, artifactID: String) extends NotNull
|
||||
{
|
||||
def % (revision: String): ModuleID =
|
||||
{
|
||||
nonEmpty(revision, "Revision")
|
||||
ModuleID(groupID, artifactID, revision, None)
|
||||
}
|
||||
}
|
||||
final class ModuleIDConfigurable private[sbt] (moduleID: ModuleID) extends NotNull
|
||||
{
|
||||
def % (configurations: String): ModuleID =
|
||||
{
|
||||
nonEmpty(configurations, "Configurations")
|
||||
import moduleID._
|
||||
ModuleID(organization, name, revision, Some(configurations))
|
||||
}
|
||||
}
|
||||
final class RepositoryName private[sbt] (name: String) extends NotNull
|
||||
{
|
||||
def at (location: String) =
|
||||
{
|
||||
nonEmpty(location, "Repository location")
|
||||
new MavenRepository(name, location)
|
||||
}
|
||||
}
|
||||
|
||||
import scala.collection.{Map, mutable}
|
||||
/** A Project that determines its tasks by reflectively finding all vals with a type
|
||||
* that conforms to Task.*/
|
||||
trait ReflectiveTasks extends Project
|
||||
{
|
||||
def tasks: Map[String, Task] = reflectiveTaskMappings
|
||||
def reflectiveTaskMappings : Map[String, Task] = Reflective.reflectiveMappings[Task](this)
|
||||
}
|
||||
/** A Project that determines its method tasks by reflectively finding all vals with a type
|
||||
* that conforms to MethodTask.*/
|
||||
trait ReflectiveMethods extends Project
|
||||
{
|
||||
def methods: Map[String, MethodTask] = reflectiveMethodMappings
|
||||
def reflectiveMethodMappings : Map[String, MethodTask] = Reflective.reflectiveMappings[MethodTask](this)
|
||||
}
|
||||
/** A Project that determines its dependencies on other projects by reflectively
|
||||
* finding all vals with a type that conforms to Project.*/
|
||||
trait ReflectiveModules extends Project
|
||||
{
|
||||
override def subProjects: Map[String, Project] = reflectiveModuleMappings
|
||||
def reflectiveModuleMappings : Map[String, Project] = Reflective.reflectiveMappings[Project](this)
|
||||
}
|
||||
/** A Project that determines its dependencies on other projects by reflectively
|
||||
* finding all vals with a type that conforms to Project and determines its tasks
|
||||
* by reflectively finding all vals with a type that conforms to Task.*/
|
||||
trait ReflectiveProject extends ReflectiveModules with ReflectiveTasks with ReflectiveMethods
|
||||
|
||||
/** This Project subclass is used to contain other projects as dependencies.*/
|
||||
class ParentProject(val info: ProjectInfo) extends BasicDependencyProject
|
||||
{
|
||||
def dependencies = info.dependencies ++ subProjects.values.toList
|
||||
/** The directories to which a project writes are listed here and is used
|
||||
* to check a project and its dependencies for collisions.*/
|
||||
override def outputDirectories = managedDependencyPath :: outputPath :: Nil
|
||||
def fullUnmanagedClasspath(config: Configuration) = unmanagedClasspath
|
||||
}
|
||||
|
||||
object Reflective
|
||||
{
|
||||
def reflectiveMappings[T](obj: AnyRef)(implicit m: scala.reflect.Manifest[T]): Map[String, T] =
|
||||
{
|
||||
val mappings = new mutable.OpenHashMap[String, T]
|
||||
for ((name, value) <- ReflectUtilities.allVals[T](obj))
|
||||
mappings(ReflectUtilities.transformCamelCase(name, '-')) = value
|
||||
mappings
|
||||
}
|
||||
}
|
||||
|
||||
/** A Project that determines its library dependencies by reflectively finding all vals with a type
|
||||
* that conforms to ModuleID.*/
|
||||
trait ReflectiveLibraryDependencies extends ManagedProject
|
||||
{
|
||||
def excludeIDs: Iterable[ModuleID] = projectID :: Nil
|
||||
def libraryDependencies: Set[ModuleID] = reflectiveLibraryDependencies
|
||||
def reflectiveLibraryDependencies : Set[ModuleID] = Set[ModuleID](Reflective.reflectiveMappings[ModuleID](this).values.toList: _*) -- excludeIDs
|
||||
}
|
||||
|
||||
trait ReflectiveConfigurations extends Project
|
||||
{
|
||||
def ivyConfigurations: Iterable[Configuration] = reflectiveIvyConfigurations
|
||||
def reflectiveIvyConfigurations: Set[Configuration] = Configurations.removeDuplicates(Reflective.reflectiveMappings[Configuration](this).values.toList)
|
||||
}
|
||||
trait ReflectiveArtifacts extends ManagedProject
|
||||
{
|
||||
def managedStyle: ManagedType
|
||||
def artifacts: Set[Artifact] =
|
||||
{
|
||||
val reflective = reflectiveArtifacts
|
||||
managedStyle match
|
||||
{
|
||||
case Maven =>reflective ++ List(Artifact(artifactID, "pom", "pom"))
|
||||
case Ivy => reflective
|
||||
}
|
||||
}
|
||||
def reflectiveArtifacts: Set[Artifact] = Set(Reflective.reflectiveMappings[Artifact](this).values.toList: _*)
|
||||
}
|
||||
/** A Project that determines its library dependencies by reflectively finding all vals with a type
|
||||
* that conforms to ModuleID.*/
|
||||
trait ReflectiveRepositories extends Project
|
||||
{
|
||||
def repositories: Set[Resolver] =
|
||||
{
|
||||
val reflective = Set[Resolver](reflectiveRepositories.values.toList: _*)
|
||||
info.parent match
|
||||
{
|
||||
case Some(p: ReflectiveRepositories) => p.repositories ++ reflective
|
||||
case None => reflective
|
||||
}
|
||||
}
|
||||
def reflectiveRepositories: Map[String, Resolver] = Reflective.reflectiveMappings[Resolver](this)
|
||||
}
|
||||
|
||||
trait ReflectiveManagedProject extends ReflectiveProject with ReflectiveArtifacts with ReflectiveRepositories with ReflectiveLibraryDependencies with ReflectiveConfigurations
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah, David MacIver
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import BasicProjectPaths._
|
||||
|
||||
sealed abstract class InternalProject extends Project
|
||||
{
|
||||
override final def historyPath = None
|
||||
override def tasks: Map[String, Task] = Map.empty
|
||||
override final protected def disableCrossPaths = false
|
||||
override final def shouldCheckOutputDirectories = false
|
||||
}
|
||||
private sealed abstract class BasicBuilderProject extends InternalProject with SimpleScalaProject
|
||||
{
|
||||
def sourceFilter = "*.scala" | "*.java"
|
||||
def jarFilter: NameFilter = "*.jar"
|
||||
def compilePath = outputPath / DefaultMainCompileDirectoryName
|
||||
def mainResourcesPath = path(DefaultResourcesDirectoryName)
|
||||
def dependencyPath = path(DefaultDependencyDirectoryName)
|
||||
def libraries = descendents(dependencyPath, jarFilter)
|
||||
override final def dependencies = Nil
|
||||
|
||||
protected final def logInfo(messages: String*): Unit = atInfo { messages.foreach(message => log.info(message)) }
|
||||
protected final def atInfo(action: => Unit)
|
||||
{
|
||||
val oldLevel = log.getLevel
|
||||
log.setLevel(Level.Info)
|
||||
action
|
||||
log.setLevel(oldLevel)
|
||||
}
|
||||
|
||||
def projectClasspath = compilePath +++ libraries +++ sbtJarPath
|
||||
def sbtJarPath = Path.lazyPathFinder { Path.fromFile(FileUtilities.sbtJar) :: Nil }
|
||||
|
||||
abstract class BuilderCompileConfiguration extends AbstractCompileConfiguration
|
||||
{
|
||||
def projectPath = info.projectPath
|
||||
def log = BasicBuilderProject.this.log
|
||||
def options = (Deprecation :: Unchecked :: Nil).map(_.asString)
|
||||
def javaOptions = Nil
|
||||
def maxErrors = ScalaProject.DefaultMaximumCompileErrors
|
||||
def compileOrder = CompileOrder.Mixed
|
||||
}
|
||||
def definitionCompileConfiguration =
|
||||
new BuilderCompileConfiguration
|
||||
{
|
||||
def label = "builder"
|
||||
def sources = (info.projectPath * sourceFilter) +++ path(DefaultSourceDirectoryName).descendentsExcept(sourceFilter, defaultExcludes)
|
||||
def outputDirectory = compilePath
|
||||
def classpath = projectClasspath
|
||||
def analysisPath = outputPath / DefaultMainAnalysisDirectoryName
|
||||
}
|
||||
|
||||
def tpe: String
|
||||
|
||||
val definitionCompileConditional = new BuilderCompileConditional(definitionCompileConfiguration, tpe)
|
||||
final class BuilderCompileConditional(config: BuilderCompileConfiguration, tpe: String) extends AbstractCompileConditional(config)
|
||||
{
|
||||
type AnalysisType = BuilderCompileAnalysis
|
||||
override protected def constructAnalysis(analysisPath: Path, projectPath: Path, log: Logger) =
|
||||
new BuilderCompileAnalysis(analysisPath, projectPath, log)
|
||||
override protected def execute(cAnalysis: ConditionalAnalysis): Option[String] =
|
||||
{
|
||||
if(cAnalysis.dirtySources.isEmpty)
|
||||
None
|
||||
else
|
||||
{
|
||||
definitionChanged()
|
||||
logInfo(
|
||||
"Recompiling " + tpe + "...",
|
||||
"\t" + cAnalysis.toString)
|
||||
super.execute(cAnalysis)
|
||||
}
|
||||
}
|
||||
protected def analysisCallback: AnalysisCallback =
|
||||
new BasicAnalysisCallback(info.projectPath, List(Project.ProjectClassName), analysis)
|
||||
{
|
||||
def foundApplication(sourcePath: Path, className: String) {}
|
||||
def foundSubclass(sourcePath: Path, subclassName: String, superclassName: String, isModule: Boolean)
|
||||
{
|
||||
if(superclassName == Project.ProjectClassName && !isModule)
|
||||
{
|
||||
log.debug("Found " + tpe + " " + subclassName)
|
||||
analysis.addProjectDefinition(sourcePath, subclassName)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
protected def definitionChanged() {}
|
||||
lazy val compile = compileTask
|
||||
def compileTask = task { definitionCompileConditional.run }
|
||||
|
||||
def projectDefinition: Either[String, Option[String]] =
|
||||
{
|
||||
definitionCompileConditional.analysis.allProjects.toList match
|
||||
{
|
||||
case Nil =>
|
||||
log.debug("No " + tpe + "s detected using default project.")
|
||||
Right(None)
|
||||
case singleDefinition :: Nil => Right(Some(singleDefinition))
|
||||
case multipleDefinitions =>Left(multipleDefinitions.mkString("Multiple " + tpe + "s detected: \n\t","\n\t","\n"))
|
||||
}
|
||||
}
|
||||
override final def methods = Map.empty
|
||||
}
|
||||
/** The project definition used to build project definitions. */
|
||||
private final class BuilderProject(val info: ProjectInfo, val pluginPath: Path, override protected val logImpl: Logger) extends BasicBuilderProject
|
||||
{
|
||||
private lazy val pluginProject =
|
||||
{
|
||||
if(pluginPath.exists)
|
||||
Some(new PluginBuilderProject(ProjectInfo(pluginPath.asFile, Nil, None)))
|
||||
else
|
||||
None
|
||||
}
|
||||
override def projectClasspath = super.projectClasspath +++ pluginProject.map(_.pluginClasspath).getOrElse(Path.emptyPathFinder)
|
||||
def tpe = "project definition"
|
||||
|
||||
override def compileTask = super.compileTask dependsOn(pluginProject.map(_.syncPlugins).toList : _*)
|
||||
|
||||
final class PluginBuilderProject(val info: ProjectInfo) extends BasicBuilderProject
|
||||
{
|
||||
override protected def logImpl = BuilderProject.this.log
|
||||
val pluginUptodate = propertyOptional[Boolean](false)
|
||||
def tpe = "plugin definition"
|
||||
def managedSourcePath = path(BasicDependencyPaths.DefaultManagedSourceDirectoryName)
|
||||
def managedDependencyPath = crossPath(BasicDependencyPaths.DefaultManagedDirectoryName)
|
||||
override protected def definitionChanged() { setUptodate(false) }
|
||||
private def setUptodate(flag: Boolean)
|
||||
{
|
||||
pluginUptodate() = flag
|
||||
saveEnvironment()
|
||||
}
|
||||
|
||||
private def pluginTask(f: => Option[String]) = task { if(!pluginUptodate.value) f else None }
|
||||
|
||||
lazy val syncPlugins = pluginTask(sync()) dependsOn(extractSources)
|
||||
lazy val extractSources = pluginTask(extract()) dependsOn(update)
|
||||
lazy val update = pluginTask(loadAndUpdate()) dependsOn(compile)
|
||||
|
||||
private def sync() = pluginCompileConditional.run orElse { setUptodate(true); None }
|
||||
private def extract() =
|
||||
{
|
||||
FileUtilities.clean(managedSourcePath, log) orElse
|
||||
Control.lazyFold(plugins.get.toList) { jar =>
|
||||
Control.thread(FileUtilities.unzip(jar, extractTo(jar), sourceFilter, log)) { extracted =>
|
||||
if(!extracted.isEmpty)
|
||||
logInfo("\tExtracted source plugin " + jar + " ...")
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
private def loadAndUpdate() =
|
||||
{
|
||||
Control.thread(projectDefinition) {
|
||||
case Some(definition) =>
|
||||
logInfo("\nUpdating plugins")
|
||||
val pluginInfo = ProjectInfo(info.projectPath.asFile, Nil, None)
|
||||
val pluginBuilder = Project.constructProject(pluginInfo, Project.getProjectClass[PluginDefinition](definition, projectClasspath))
|
||||
pluginBuilder.projectName() = "Plugin builder"
|
||||
pluginBuilder.projectVersion() = OpaqueVersion("1.0")
|
||||
val result = pluginBuilder.update.run
|
||||
if(result.isEmpty)
|
||||
{
|
||||
atInfo {
|
||||
log.success("Plugins updated successfully.")
|
||||
log.info("")
|
||||
}
|
||||
}
|
||||
result
|
||||
case None => None
|
||||
}
|
||||
}
|
||||
def extractTo(jar: Path) =
|
||||
{
|
||||
val name = jar.asFile.getName
|
||||
managedSourcePath / name.substring(0, name.length - ".jar".length)
|
||||
}
|
||||
def plugins = descendents(managedDependencyPath, jarFilter)
|
||||
def pluginClasspath = plugins +++ pluginCompileConfiguration.outputDirectory
|
||||
|
||||
lazy val pluginCompileConditional = new BuilderCompileConditional(pluginCompileConfiguration, "plugin")
|
||||
lazy val pluginCompileConfiguration =
|
||||
new BuilderCompileConfiguration
|
||||
{
|
||||
def label = "plugin builder"
|
||||
def sources = descendents(managedSourcePath, sourceFilter)
|
||||
def outputDirectory = outputPath / "plugin-classes"
|
||||
def classpath = sbtJarPath
|
||||
def analysisPath = outputPath / "plugin-analysis"
|
||||
}
|
||||
}
|
||||
}
|
||||
class PluginDefinition(val info: ProjectInfo) extends InternalProject with BasicManagedProject
|
||||
{
|
||||
override final def outputPattern = "[artifact](-[revision]).[ext]"
|
||||
override final val tasks = Map("update" -> update)
|
||||
override def projectClasspath(config: Configuration) = Path.emptyPathFinder
|
||||
override def dependencies = info.dependencies
|
||||
}
|
||||
class PluginProject(info: ProjectInfo) extends DefaultProject(info)
|
||||
{
|
||||
override def unmanagedClasspath = super.unmanagedClasspath +++ Path.lazyPathFinder(Path.fromFile(FileUtilities.sbtJar) :: Nil)
|
||||
override def packageAction = packageSrc
|
||||
override def packageSrcJar = jarPath
|
||||
override def useMavenConfigurations = true
|
||||
override def managedStyle = ManagedStyle.Maven
|
||||
}
|
||||
|
|
@ -0,0 +1,197 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import java.net.{URI, URL, URLClassLoader}
|
||||
import java.util.Collections
|
||||
import scala.collection.Set
|
||||
import scala.collection.mutable.{HashSet, ListBuffer}
|
||||
|
||||
private[sbt] object ClasspathUtilities
|
||||
{
|
||||
def toClasspath(finder: PathFinder): Array[URL] = toClasspath(finder.get)
|
||||
def toClasspath(paths: Iterable[Path]): Array[URL] = paths.map(_.asURL).toSeq.toArray
|
||||
def toLoader(finder: PathFinder): ClassLoader = toLoader(finder.get)
|
||||
def toLoader(paths: Iterable[Path]): ClassLoader = new URLClassLoader(toClasspath(paths), getClass.getClassLoader)
|
||||
|
||||
def isArchive(path: Path): Boolean = isArchive(path.asFile)
|
||||
def isArchive(file: File): Boolean = isArchiveName(file.getName)
|
||||
def isArchiveName(fileName: String) = fileName.endsWith(".jar") || fileName.endsWith(".zip")
|
||||
// Partitions the given classpath into (jars, directories)
|
||||
def separate(paths: Iterable[File]): (Iterable[File], Iterable[File]) = paths.partition(isArchive)
|
||||
// Partitions the given classpath into (jars, directories)
|
||||
def separatePaths(paths: Iterable[Path]) = separate(paths.map(_.asFile.getCanonicalFile))
|
||||
private[sbt] def buildSearchPaths(classpath: Iterable[Path]): (wrap.Set[File], wrap.Set[File]) =
|
||||
{
|
||||
val (jars, dirs) = separatePaths(classpath)
|
||||
(linkedSet(jars ++ extraJars.toList), linkedSet(dirs ++ extraDirs.toList))
|
||||
}
|
||||
private[sbt] def onClasspath(classpathJars: wrap.Set[File], classpathDirectories: wrap.Set[File], file: File): Boolean =
|
||||
{
|
||||
val f = file.getCanonicalFile
|
||||
if(ClasspathUtilities.isArchive(f))
|
||||
classpathJars.contains(f)
|
||||
else
|
||||
classpathDirectories.toList.find(Path.relativize(_, f).isDefined).isDefined
|
||||
}
|
||||
|
||||
/** Returns all entries in 'classpath' that correspond to a compiler plugin.*/
|
||||
def compilerPlugins(classpath: Iterable[Path]): Iterable[File] =
|
||||
{
|
||||
val loader = new URLClassLoader(classpath.map(_.asURL).toList.toArray)
|
||||
wrap.Wrappers.toList(loader.getResources("scalac-plugin.xml")).flatMap(asFile)
|
||||
}
|
||||
/** Converts the given URL to a File. If the URL is for an entry in a jar, the File for the jar is returned. */
|
||||
private[sbt] def asFile(url: URL) =
|
||||
{
|
||||
try
|
||||
{
|
||||
url.getProtocol match
|
||||
{
|
||||
case "file" => new File(url.toURI) :: Nil
|
||||
case "jar" =>
|
||||
val path = url.getPath
|
||||
val end = path.indexOf('!')
|
||||
new File(new URI(if(end == -1) path else path.substring(0, end))) :: Nil
|
||||
case _ => Nil
|
||||
}
|
||||
}
|
||||
catch { case e: Exception => Nil }
|
||||
}
|
||||
|
||||
private lazy val (extraJars, extraDirs) =
|
||||
{
|
||||
import scala.tools.nsc.GenericRunnerCommand
|
||||
val settings = (new GenericRunnerCommand(Nil, message => error(message))).settings
|
||||
val bootPaths = FileUtilities.pathSplit(settings.bootclasspath.value).map(p => new File(p)).toList
|
||||
val (bootJars, bootDirs) = separate(bootPaths)
|
||||
val extJars =
|
||||
{
|
||||
val buffer = new ListBuffer[File]
|
||||
def findJars(dir: File)
|
||||
{
|
||||
buffer ++= dir.listFiles(new SimpleFileFilter(isArchive))
|
||||
for(dir <- dir.listFiles(DirectoryFilter))
|
||||
findJars(dir)
|
||||
}
|
||||
for(path <- FileUtilities.pathSplit(settings.extdirs.value); val dir = new File(path) if dir.isDirectory)
|
||||
findJars(dir)
|
||||
buffer.readOnly.map(_.getCanonicalFile)
|
||||
}
|
||||
(linkedSet(extJars ++ bootJars), linkedSet(bootDirs))
|
||||
}
|
||||
private def linkedSet[T](s: Iterable[T]): wrap.Set[T] =
|
||||
{
|
||||
val set = new wrap.MutableSetWrapper(new java.util.LinkedHashSet[T])
|
||||
set ++= s
|
||||
set.readOnly
|
||||
}
|
||||
}
|
||||
|
||||
private abstract class LoaderBase(urls: Array[URL], parent: ClassLoader) extends URLClassLoader(urls, parent) with NotNull
|
||||
{
|
||||
require(parent != null) // included because a null parent is legitimate in Java
|
||||
@throws(classOf[ClassNotFoundException])
|
||||
override final def loadClass(className: String, resolve: Boolean): Class[_] =
|
||||
{
|
||||
val loaded = findLoadedClass(className)
|
||||
val found =
|
||||
if(loaded == null)
|
||||
doLoadClass(className)
|
||||
else
|
||||
loaded
|
||||
|
||||
if(resolve)
|
||||
resolveClass(found)
|
||||
found
|
||||
}
|
||||
protected def doLoadClass(className: String): Class[_]
|
||||
protected final def selfLoadClass(className: String): Class[_] = super.loadClass(className, false)
|
||||
}
|
||||
private class IntermediateLoader(urls: Array[URL], parent: ClassLoader) extends LoaderBase(urls, parent) with NotNull
|
||||
{
|
||||
def doLoadClass(className: String): Class[_] =
|
||||
{
|
||||
// if this loader is asked to load an sbt class, it must be because the project we are building is sbt itself,
|
||||
// so we want to load the version of classes on the project classpath, not the parent
|
||||
if(className.startsWith(Loaders.SbtPackage))
|
||||
findClass(className)
|
||||
else
|
||||
selfLoadClass(className)
|
||||
}
|
||||
}
|
||||
/** Delegates class loading to `parent` for all classes included by `filter`. An attempt to load classes excluded by `filter`
|
||||
* results in a `ClassNotFoundException`.*/
|
||||
private class FilteredLoader(parent: ClassLoader, filter: ClassFilter) extends ClassLoader(parent) with NotNull
|
||||
{
|
||||
require(parent != null) // included because a null parent is legitimate in Java
|
||||
def this(parent: ClassLoader, excludePackages: Iterable[String]) = this(parent, new ExcludePackagesFilter(excludePackages))
|
||||
|
||||
@throws(classOf[ClassNotFoundException])
|
||||
override final def loadClass(className: String, resolve: Boolean): Class[_] =
|
||||
{
|
||||
if(filter.include(className))
|
||||
super.loadClass(className, resolve)
|
||||
else
|
||||
throw new ClassNotFoundException(className)
|
||||
}
|
||||
}
|
||||
private class SelectiveLoader(urls: Array[URL], parent: ClassLoader, filter: ClassFilter) extends URLClassLoader(urls, parent) with NotNull
|
||||
{
|
||||
require(parent != null) // included because a null parent is legitimate in Java
|
||||
def this(urls: Array[URL], parent: ClassLoader, includePackages: Iterable[String]) = this(urls, parent, new IncludePackagesFilter(includePackages))
|
||||
|
||||
@throws(classOf[ClassNotFoundException])
|
||||
override final def loadClass(className: String, resolve: Boolean): Class[_] =
|
||||
{
|
||||
if(filter.include(className))
|
||||
super.loadClass(className, resolve)
|
||||
else
|
||||
{
|
||||
val loaded = parent.loadClass(className)
|
||||
if(resolve)
|
||||
resolveClass(loaded)
|
||||
loaded
|
||||
}
|
||||
}
|
||||
}
|
||||
private trait ClassFilter
|
||||
{
|
||||
def include(className: String): Boolean
|
||||
}
|
||||
private abstract class PackageFilter(packages: Iterable[String]) extends ClassFilter
|
||||
{
|
||||
require(packages.forall(_.endsWith(".")))
|
||||
protected final def matches(className: String): Boolean = packages.exists(className.startsWith)
|
||||
}
|
||||
private class ExcludePackagesFilter(exclude: Iterable[String]) extends PackageFilter(exclude)
|
||||
{
|
||||
def include(className: String): Boolean = !matches(className)
|
||||
}
|
||||
private class IncludePackagesFilter(include: Iterable[String]) extends PackageFilter(include)
|
||||
{
|
||||
def include(className: String): Boolean = matches(className)
|
||||
}
|
||||
|
||||
private class LazyFrameworkLoader(runnerClassName: String, urls: Array[URL], parent: ClassLoader, grandparent: ClassLoader)
|
||||
extends LoaderBase(urls, parent) with NotNull
|
||||
{
|
||||
def doLoadClass(className: String): Class[_] =
|
||||
{
|
||||
if(Loaders.isNestedOrSelf(className, runnerClassName))
|
||||
findClass(className)
|
||||
else if(Loaders.isSbtClass(className)) // we circumvent the parent loader because we know that we want the
|
||||
grandparent.loadClass(className) // version of sbt that is currently the builder (not the project being built)
|
||||
else
|
||||
parent.loadClass(className)
|
||||
}
|
||||
}
|
||||
private object Loaders
|
||||
{
|
||||
val SbtPackage = "sbt."
|
||||
def isNestedOrSelf(className: String, checkAgainst: String) =
|
||||
className == checkAgainst || className.startsWith(checkAgainst + "$")
|
||||
def isSbtClass(className: String) = className.startsWith(Loaders.SbtPackage)
|
||||
}
|
||||
|
|
@ -0,0 +1,279 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
object CompileOrder extends Enumeration
|
||||
{
|
||||
val Mixed, JavaThenScala, ScalaThenJava = Value
|
||||
}
|
||||
sealed abstract class CompilerCore
|
||||
{
|
||||
val ClasspathOptionString = "-classpath"
|
||||
val OutputOptionString = "-d"
|
||||
|
||||
// Returns false if there were errors, true if there were not.
|
||||
protected def process(args: List[String], log: Logger): Boolean
|
||||
// Returns false if there were errors, true if there were not.
|
||||
protected def processJava(args: List[String], log: Logger): Boolean = true
|
||||
def actionStartMessage(label: String): String
|
||||
def actionNothingToDoMessage: String
|
||||
def actionSuccessfulMessage: String
|
||||
def actionUnsuccessfulMessage: String
|
||||
|
||||
final def apply(label: String, sources: Iterable[Path], classpathString: String, outputDirectory: Path, options: Seq[String], log: Logger): Option[String] =
|
||||
apply(label, sources, classpathString, outputDirectory, options, Nil, CompileOrder.Mixed, log)
|
||||
final def apply(label: String, sources: Iterable[Path], classpathString: String, outputDirectory: Path, options: Seq[String], javaOptions: Seq[String], order: CompileOrder.Value, log: Logger): Option[String] =
|
||||
{
|
||||
log.info(actionStartMessage(label))
|
||||
val classpathOption: List[String] =
|
||||
if(classpathString.isEmpty)
|
||||
Nil
|
||||
else
|
||||
List(ClasspathOptionString, classpathString)
|
||||
val outputDir = outputDirectory.asFile
|
||||
FileUtilities.createDirectory(outputDir, log) orElse
|
||||
{
|
||||
val classpathAndOut: List[String] = OutputOptionString :: outputDir.getAbsolutePath :: classpathOption
|
||||
|
||||
Control.trapUnit("Compiler error: ", log)
|
||||
{
|
||||
val sourceList = sources.map(_.asFile.getAbsolutePath).toList
|
||||
if(sourceList.isEmpty)
|
||||
{
|
||||
log.info(actionNothingToDoMessage)
|
||||
None
|
||||
}
|
||||
else
|
||||
{
|
||||
def filteredSources(extension: String) = sourceList.filter(_.endsWith(extension))
|
||||
def compile(label: String, sources: List[String], options: Seq[String])(process: (List[String], Logger) => Boolean) =
|
||||
{
|
||||
if(sources.isEmpty)
|
||||
{
|
||||
log.debug("No "+label+" sources to compile.")
|
||||
true
|
||||
}
|
||||
else
|
||||
{
|
||||
val arguments = (options ++ classpathAndOut ++ sources).toList
|
||||
log.debug(label + " arguments: " + arguments.mkString(" "))
|
||||
process(arguments, log)
|
||||
}
|
||||
}
|
||||
def scalaCompile = () =>
|
||||
{
|
||||
val scalaSourceList = if(order == CompileOrder.Mixed) sourceList else filteredSources(".scala")
|
||||
compile("Scala", scalaSourceList, options)(process)
|
||||
}
|
||||
def javaCompile = () =>
|
||||
{
|
||||
val javaSourceList = filteredSources(".java")
|
||||
compile("Java", javaSourceList, javaOptions)(processJava)
|
||||
}
|
||||
|
||||
val (first, second) = if(order == CompileOrder.JavaThenScala) (javaCompile, scalaCompile) else (scalaCompile, javaCompile)
|
||||
if(first() && second())
|
||||
{
|
||||
log.info(actionSuccessfulMessage)
|
||||
None
|
||||
}
|
||||
else
|
||||
Some(actionUnsuccessfulMessage)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sealed abstract class CompilerBase extends CompilerCore
|
||||
{
|
||||
def actionStartMessage(label: String) = "Compiling " + label + " sources..."
|
||||
val actionNothingToDoMessage = "Nothing to compile."
|
||||
val actionSuccessfulMessage = "Compilation successful."
|
||||
val actionUnsuccessfulMessage = "Compilation unsuccessful."
|
||||
}
|
||||
final class ForkCompile(config: ForkScalaCompiler) extends CompilerBase
|
||||
{
|
||||
import java.io.File
|
||||
protected def process(arguments: List[String], log: Logger) =
|
||||
Fork.scalac(config.javaHome, config.compileJVMOptions, config.scalaJars, arguments, log) == 0
|
||||
override protected def processJava(args: List[String], log: Logger) =
|
||||
Fork.javac(config.javaHome, args, log) == 0
|
||||
}
|
||||
object ForkCompile
|
||||
{
|
||||
def apply(config: ForkScalaCompiler, conditional: CompileConditional) =
|
||||
{
|
||||
import conditional.config.{compileOrder, classpath, javaOptions, label, log, options, outputDirectory, sources}
|
||||
// recompile only if any sources were modified after any classes or no classes exist
|
||||
val sourcePaths = sources.get
|
||||
val newestSource = (0L /: sourcePaths)(_ max _.lastModified)
|
||||
val products = (outputDirectory ** GlobFilter("*.class")).get
|
||||
val oldestClass = (java.lang.Long.MAX_VALUE /: products)(_ min _.lastModified)
|
||||
if(products.isEmpty || newestSource > oldestClass)
|
||||
{
|
||||
// full recompile, since we are not doing proper dependency tracking
|
||||
FileUtilities.clean(outputDirectory :: Nil, log)
|
||||
val compiler = new ForkCompile(config)
|
||||
FileUtilities.createDirectory(outputDirectory.asFile, log)
|
||||
compiler(label, sourcePaths, Path.makeString(classpath.get), outputDirectory, options, javaOptions, compileOrder, log)
|
||||
}
|
||||
else
|
||||
{
|
||||
log.info("Compilation up to date.")
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The following code is based on scala.tools.nsc.Main and scala.tools.nsc.ScalaDoc
|
||||
// Copyright 2005-2008 LAMP/EPFL
|
||||
// Original author: Martin Odersky
|
||||
|
||||
final class Compile(maximumErrors: Int) extends CompilerBase
|
||||
{
|
||||
protected def process(arguments: List[String], log: Logger) =
|
||||
{
|
||||
import scala.tools.nsc.{CompilerCommand, FatalError, Global, Settings, reporters, util}
|
||||
import util.FakePos
|
||||
var reporter = new LoggerReporter(maximumErrors, log)
|
||||
val settings = new Settings(reporter.error)
|
||||
val command = new CompilerCommand(arguments, settings, error, false)
|
||||
|
||||
object compiler extends Global(command.settings, reporter)
|
||||
if(!reporter.hasErrors)
|
||||
{
|
||||
val run = new compiler.Run
|
||||
run compile command.files
|
||||
reporter.printSummary()
|
||||
}
|
||||
!reporter.hasErrors
|
||||
}
|
||||
override protected def processJava(args: List[String], log: Logger) =
|
||||
(Process("javac", args) ! log) == 0
|
||||
}
|
||||
final class Scaladoc(maximumErrors: Int) extends CompilerCore
|
||||
{
|
||||
protected def process(arguments: List[String], log: Logger) =
|
||||
{
|
||||
import scala.tools.nsc.{doc, CompilerCommand, FatalError, Global, reporters, util}
|
||||
import util.FakePos
|
||||
val reporter = new LoggerReporter(maximumErrors, log)
|
||||
val docSettings: doc.Settings = new doc.Settings(reporter.error)
|
||||
val command = new CompilerCommand(arguments, docSettings, error, false)
|
||||
object compiler extends Global(command.settings, reporter)
|
||||
{
|
||||
override val onlyPresentation = true
|
||||
}
|
||||
if(!reporter.hasErrors)
|
||||
{
|
||||
val run = new compiler.Run
|
||||
run compile command.files
|
||||
val generator = new doc.DefaultDocDriver
|
||||
{
|
||||
lazy val global: compiler.type = compiler
|
||||
lazy val settings = docSettings
|
||||
}
|
||||
generator.process(run.units)
|
||||
reporter.printSummary()
|
||||
}
|
||||
!reporter.hasErrors
|
||||
}
|
||||
def actionStartMessage(label: String) = "Generating API documentation for " + label + " sources..."
|
||||
val actionNothingToDoMessage = "No sources specified."
|
||||
val actionSuccessfulMessage = "API documentation generation successful."
|
||||
def actionUnsuccessfulMessage = "API documentation generation unsuccessful."
|
||||
}
|
||||
|
||||
// The following code is based on scala.tools.nsc.reporters.{AbstractReporter, ConsoleReporter}
|
||||
// Copyright 2002-2008 LAMP/EPFL
|
||||
// Original author: Martin Odersky
|
||||
final class LoggerReporter(maximumErrors: Int, log: Logger) extends scala.tools.nsc.reporters.Reporter
|
||||
{
|
||||
import scala.tools.nsc.util.{FakePos,Position}
|
||||
private val positions = new scala.collection.mutable.HashMap[Position, Severity]
|
||||
|
||||
def error(msg: String) { error(FakePos("scalac"), msg) }
|
||||
|
||||
def printSummary()
|
||||
{
|
||||
if(WARNING.count > 0)
|
||||
log.warn(countElementsAsString(WARNING.count, "warning") + " found")
|
||||
if(ERROR.count > 0)
|
||||
log.error(countElementsAsString(ERROR.count, "error") + " found")
|
||||
}
|
||||
|
||||
def display(pos: Position, msg: String, severity: Severity)
|
||||
{
|
||||
severity.count += 1
|
||||
if(severity != ERROR || maximumErrors < 0 || severity.count <= maximumErrors)
|
||||
print(severityToLevel(severity), pos, msg)
|
||||
}
|
||||
private def severityToLevel(severity: Severity): Level.Value =
|
||||
severity match
|
||||
{
|
||||
case ERROR => Level.Error
|
||||
case WARNING => Level.Warn
|
||||
case INFO => Level.Info
|
||||
}
|
||||
|
||||
private def print(level: Level.Value, posIn: Position, msg: String)
|
||||
{
|
||||
if(posIn == null)
|
||||
log.log(level, msg)
|
||||
else
|
||||
{
|
||||
val pos = posIn.inUltimateSource(posIn.source.getOrElse(null))
|
||||
def message =
|
||||
{
|
||||
val sourcePrefix =
|
||||
pos match
|
||||
{
|
||||
case FakePos(msg) => msg + " "
|
||||
case _ => pos.source.map(_.file.path).getOrElse("")
|
||||
}
|
||||
val lineNumberString = pos.line.map(line => ":" + line + ":").getOrElse(":") + " "
|
||||
sourcePrefix + lineNumberString + msg
|
||||
}
|
||||
log.log(level, message)
|
||||
if (!pos.line.isEmpty)
|
||||
{
|
||||
log.log(level, pos.lineContent.stripLineEnd) // source line with error/warning
|
||||
for(column <- pos.column if column > 0) // pointer to the column position of the error/warning
|
||||
log.log(level, (" " * (column-1)) + '^')
|
||||
}
|
||||
}
|
||||
}
|
||||
override def reset =
|
||||
{
|
||||
super.reset
|
||||
positions.clear
|
||||
}
|
||||
|
||||
protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean)
|
||||
{
|
||||
severity match
|
||||
{
|
||||
case WARNING | ERROR =>
|
||||
{
|
||||
if(!testAndLog(pos, severity))
|
||||
display(pos, msg, severity)
|
||||
}
|
||||
case _ => display(pos, msg, severity)
|
||||
}
|
||||
}
|
||||
|
||||
private def testAndLog(pos: Position, severity: Severity): Boolean =
|
||||
{
|
||||
if(pos == null || pos.offset.isEmpty)
|
||||
false
|
||||
else if(positions.get(pos).map(_ >= severity).getOrElse(false))
|
||||
true
|
||||
else
|
||||
{
|
||||
positions(pos) = severity
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,381 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
trait Conditional[Source, Product, External] extends NotNull
|
||||
{
|
||||
type AnalysisType <: TaskAnalysis[Source, Product, External]
|
||||
val analysis: AnalysisType = loadAnalysis
|
||||
|
||||
protected def loadAnalysis: AnalysisType
|
||||
protected def log: Logger
|
||||
|
||||
protected def productType: String
|
||||
protected def productTypePlural: String
|
||||
|
||||
protected def sourcesToProcess: Iterable[Source]
|
||||
|
||||
protected def sourceExists(source: Source): Boolean
|
||||
protected def sourceLastModified(source: Source): Long
|
||||
|
||||
protected def productExists(product: Product): Boolean
|
||||
protected def productLastModified(product: Product): Long
|
||||
|
||||
protected def externalInfo(externals: Iterable[External]): Iterable[(External, ExternalInfo)]
|
||||
|
||||
protected def execute(cAnalysis: ConditionalAnalysis): Option[String]
|
||||
|
||||
final case class ExternalInfo(available: Boolean, lastModified: Long) extends NotNull
|
||||
trait ConditionalAnalysis extends NotNull
|
||||
{
|
||||
def dirtySources: Iterable[Source]
|
||||
def cleanSources: Iterable[Source]
|
||||
def directlyModifiedSourcesCount: Int
|
||||
def invalidatedSourcesCount: Int
|
||||
def removedSourcesCount: Int
|
||||
}
|
||||
|
||||
final def run =
|
||||
{
|
||||
val result = execute(analyze)
|
||||
processingComplete(result.isEmpty)
|
||||
result
|
||||
}
|
||||
private def analyze =
|
||||
{
|
||||
import scala.collection.mutable.HashSet
|
||||
|
||||
val sourcesSnapshot = sourcesToProcess
|
||||
val removedSources = new HashSet[Source]
|
||||
removedSources ++= analysis.allSources
|
||||
removedSources --= sourcesSnapshot
|
||||
val removedCount = removedSources.size
|
||||
for(removed <- removedSources)
|
||||
analysis.removeDependent(removed)
|
||||
|
||||
val unmodified = new HashSet[Source]
|
||||
val modified = new HashSet[Source]
|
||||
|
||||
for(source <- sourcesSnapshot)
|
||||
{
|
||||
if(isSourceModified(source))
|
||||
{
|
||||
log.debug("Source " + source + " directly modified.")
|
||||
modified += source
|
||||
}
|
||||
else
|
||||
{
|
||||
log.debug("Source " + source + " unmodified.")
|
||||
unmodified += source
|
||||
}
|
||||
}
|
||||
val directlyModifiedCount = modified.size
|
||||
for((external, info) <- externalInfo(analysis.allExternals))
|
||||
{
|
||||
val dependentSources = analysis.externalDependencies(external).getOrElse(Set.empty)
|
||||
if(info.available)
|
||||
{
|
||||
val dependencyLastModified = info.lastModified
|
||||
for(dependentSource <- dependentSources; dependentProducts <- analysis.products(dependentSource))
|
||||
{
|
||||
dependentProducts.find(p => productLastModified(p) < dependencyLastModified) match
|
||||
{
|
||||
case Some(modifiedProduct) =>
|
||||
{
|
||||
log.debug(productType + " " + modifiedProduct + " older than external dependency " + external)
|
||||
unmodified -= dependentSource
|
||||
modified += dependentSource
|
||||
}
|
||||
case None => ()
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
log.debug("External dependency " + external + " not found.")
|
||||
unmodified --= dependentSources
|
||||
modified ++= dependentSources
|
||||
analysis.removeExternalDependency(external)
|
||||
}
|
||||
}
|
||||
|
||||
val handled = new scala.collection.mutable.HashSet[Source]
|
||||
val transitive = !java.lang.Boolean.getBoolean("sbt.intransitive")
|
||||
def markModified(changed: Iterable[Source]) { for(c <- changed if !handled.contains(c)) markSourceModified(c) }
|
||||
def markSourceModified(src: Source)
|
||||
{
|
||||
unmodified -= src
|
||||
modified += src
|
||||
handled += src
|
||||
if(transitive)
|
||||
markDependenciesModified(src)
|
||||
}
|
||||
def markDependenciesModified(src: Source) { analysis.removeDependencies(src).map(markModified) }
|
||||
|
||||
markModified(modified.toList)
|
||||
if(transitive)
|
||||
removedSources.foreach(markDependenciesModified)
|
||||
|
||||
for(changed <- removedSources ++ modified)
|
||||
analysis.removeSource(changed)
|
||||
|
||||
new ConditionalAnalysis
|
||||
{
|
||||
def dirtySources = wrap.Wrappers.readOnly(modified)
|
||||
def cleanSources = wrap.Wrappers.readOnly(unmodified)
|
||||
def directlyModifiedSourcesCount = directlyModifiedCount
|
||||
def invalidatedSourcesCount = dirtySources.size - directlyModifiedCount
|
||||
def removedSourcesCount = removedCount
|
||||
override def toString =
|
||||
{
|
||||
" Source analysis: " + directlyModifiedSourcesCount + " new/modified, " +
|
||||
invalidatedSourcesCount + " indirectly invalidated, " +
|
||||
removedSourcesCount + " removed."
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected def checkLastModified = true
|
||||
protected def noProductsImpliesModified = true
|
||||
protected def isSourceModified(source: Source) =
|
||||
{
|
||||
analysis.products(source) match
|
||||
{
|
||||
case None =>
|
||||
{
|
||||
log.debug("New file " + source)
|
||||
true
|
||||
}
|
||||
case Some(sourceProducts) =>
|
||||
{
|
||||
val sourceModificationTime = sourceLastModified(source)
|
||||
def isOutofdate(p: Product) =
|
||||
!productExists(p) || (checkLastModified && productLastModified(p) < sourceModificationTime)
|
||||
|
||||
sourceProducts.find(isOutofdate) match
|
||||
{
|
||||
case Some(modifiedProduct) =>
|
||||
log.debug("Outdated " + productType + ": " + modifiedProduct + " for source " + source)
|
||||
true
|
||||
case None =>
|
||||
if(noProductsImpliesModified && sourceProducts.isEmpty)
|
||||
{
|
||||
// necessary for change detection that depends on last modified
|
||||
log.debug("Source " + source + " has no products, marking it modified.")
|
||||
true
|
||||
}
|
||||
else
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
protected def processingComplete(success: Boolean)
|
||||
{
|
||||
if(success)
|
||||
{
|
||||
analysis.save()
|
||||
log.info(" Post-analysis: " + analysis.allProducts.toSeq.length + " " + productTypePlural + ".")
|
||||
}
|
||||
else
|
||||
analysis.revert()
|
||||
}
|
||||
}
|
||||
|
||||
abstract class AbstractCompileConfiguration extends NotNull
|
||||
{
|
||||
def label: String
|
||||
def sources: PathFinder
|
||||
def outputDirectory: Path
|
||||
def classpath: PathFinder
|
||||
def analysisPath: Path
|
||||
def projectPath: Path
|
||||
def log: Logger
|
||||
def options: Seq[String]
|
||||
def javaOptions: Seq[String]
|
||||
def maxErrors: Int
|
||||
def compileOrder: CompileOrder.Value
|
||||
}
|
||||
abstract class CompileConfiguration extends AbstractCompileConfiguration
|
||||
{
|
||||
def testDefinitionClassNames: Iterable[String]
|
||||
}
|
||||
import java.io.File
|
||||
class CompileConditional(override val config: CompileConfiguration) extends AbstractCompileConditional(config)
|
||||
{
|
||||
import config._
|
||||
type AnalysisType = CompileAnalysis
|
||||
protected def constructAnalysis(analysisPath: Path, projectPath: Path, log: Logger) =
|
||||
new CompileAnalysis(analysisPath, projectPath, log)
|
||||
protected def analysisCallback = new CompileAnalysisCallback
|
||||
protected class CompileAnalysisCallback extends BasicCompileAnalysisCallback(projectPath, testDefinitionClassNames, analysis)
|
||||
{
|
||||
def foundSubclass(sourcePath: Path, subclassName: String, superclassName: String, isModule: Boolean)
|
||||
{
|
||||
analysis.addTest(sourcePath, TestDefinition(isModule, subclassName, superclassName))
|
||||
}
|
||||
}
|
||||
}
|
||||
abstract class AbstractCompileConditional(val config: AbstractCompileConfiguration) extends Conditional[Path, Path, File]
|
||||
{
|
||||
import config._
|
||||
type AnalysisType <: BasicCompileAnalysis
|
||||
protected def loadAnalysis =
|
||||
{
|
||||
val a = constructAnalysis(analysisPath, projectPath, log)
|
||||
for(errorMessage <- a.load())
|
||||
error(errorMessage)
|
||||
a
|
||||
}
|
||||
protected def constructAnalysis(analysisPath: Path, projectPath: Path, log: Logger): AnalysisType
|
||||
|
||||
protected def log = config.log
|
||||
|
||||
protected def productType = "class"
|
||||
protected def productTypePlural = "classes"
|
||||
protected def sourcesToProcess = sources.get
|
||||
|
||||
protected def sourceExists(source: Path) = source.asFile.exists
|
||||
protected def sourceLastModified(source: Path) = source.asFile.lastModified
|
||||
|
||||
protected def productExists(product: Path) = product.asFile.exists
|
||||
protected def productLastModified(product: Path) = product.asFile.lastModified
|
||||
|
||||
protected def externalInfo(externals: Iterable[File]) =
|
||||
{
|
||||
val (classpathJars, classpathDirs) = ClasspathUtilities.buildSearchPaths(classpath.get)
|
||||
for(external <- externals) yield
|
||||
{
|
||||
val available = external.exists && ClasspathUtilities.onClasspath(classpathJars, classpathDirs, external)
|
||||
if(!available)
|
||||
log.debug("External " + external + (if(external.exists) " not on classpath." else " does not exist."))
|
||||
(external, ExternalInfo(available, external.lastModified))
|
||||
}
|
||||
}
|
||||
|
||||
import ChangeDetection.{LastModifiedOnly, HashOnly, HashAndLastModified, HashAndProductsExist}
|
||||
protected def changeDetectionMethod: ChangeDetection.Value = HashAndProductsExist
|
||||
override protected def checkLastModified = changeDetectionMethod != HashAndProductsExist
|
||||
override protected def noProductsImpliesModified = changeDetectionMethod == LastModifiedOnly
|
||||
override protected def isSourceModified(source: Path) =
|
||||
changeDetectionMethod match
|
||||
{
|
||||
case HashAndLastModified | HashAndProductsExist =>
|
||||
// behavior will differ because of checkLastModified
|
||||
// hash modified must come first so that the latest hash is calculated for every source
|
||||
hashModified(source) || super.isSourceModified(source)
|
||||
case HashOnly => hashModified(source)
|
||||
case LastModifiedOnly => super.isSourceModified(source)
|
||||
}
|
||||
|
||||
import scala.collection.mutable.{Buffer, ListBuffer}
|
||||
private val newHashes: Buffer[(Path, Option[Array[Byte]])] = new ListBuffer
|
||||
private def warnHashError(source: Path, message: String)
|
||||
{
|
||||
log.warn("Error computing hash for source " + source + ": " + message)
|
||||
newHashes += ((source, None))
|
||||
}
|
||||
protected def hashModified(source: Path) =
|
||||
{
|
||||
source.isDirectory ||
|
||||
(analysis.hash(source) match
|
||||
{
|
||||
case None =>
|
||||
log.debug("Source " + source + " had no hash, marking modified.")
|
||||
Hash(source, log).fold(err => warnHashError(source, err), newHash => newHashes += ((source, Some(newHash))))
|
||||
true
|
||||
case Some(oldHash) =>
|
||||
{
|
||||
Hash(source, log) match
|
||||
{
|
||||
case Left(err) =>
|
||||
warnHashError(source, err)
|
||||
log.debug("Assuming source is modified because of error.")
|
||||
true
|
||||
case Right(newHash) =>
|
||||
newHashes += ((source, Some(newHash)))
|
||||
val different = !(oldHash deepEquals newHash)
|
||||
if(different)
|
||||
log.debug("Hash for source " + source + " changed (was " + Hash.toHex(oldHash) +
|
||||
", is now " + Hash.toHex(newHash) + "), marking modified.")
|
||||
different
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
protected def execute(executeAnalysis: ConditionalAnalysis) =
|
||||
{
|
||||
log.info(executeAnalysis.toString)
|
||||
finishHashes()
|
||||
import executeAnalysis.dirtySources
|
||||
|
||||
// the output directory won't show up in the classpath unless it exists, so do this before classpath.get
|
||||
val outputDir = outputDirectory.asFile
|
||||
FileUtilities.createDirectory(outputDir, log)
|
||||
|
||||
val cp = classpath.get
|
||||
if(!dirtySources.isEmpty)
|
||||
checkClasspath(cp)
|
||||
val classpathString = Path.makeString(cp)
|
||||
val id = AnalysisCallback.register(analysisCallback)
|
||||
val allOptions = (("-Xplugin:" + FileUtilities.sbtJar.getAbsolutePath) ::
|
||||
("-P:sbt-analyzer:callback:" + id.toString) :: Nil) ++ options
|
||||
val r = (new Compile(config.maxErrors))(label, dirtySources, classpathString, outputDirectory, allOptions, javaOptions, compileOrder, log)
|
||||
AnalysisCallback.unregister(id)
|
||||
if(log.atLevel(Level.Debug))
|
||||
{
|
||||
/** This checks that the plugin accounted for all classes in the output directory.*/
|
||||
val classes = scala.collection.mutable.HashSet(analysis.allProducts.toSeq: _*)
|
||||
var missed = 0
|
||||
for(c <- (outputDirectory ** GlobFilter("*.class")).get)
|
||||
{
|
||||
if(!classes.contains(c))
|
||||
{
|
||||
missed += 1
|
||||
log.debug("Missed class: " + c)
|
||||
}
|
||||
}
|
||||
log.debug("Total missed classes: " + missed)
|
||||
}
|
||||
r
|
||||
}
|
||||
private def finishHashes()
|
||||
{
|
||||
if(changeDetectionMethod == LastModifiedOnly)
|
||||
analysis.clearHashes()
|
||||
else
|
||||
{
|
||||
for((path, hash) <- newHashes)
|
||||
{
|
||||
hash match
|
||||
{
|
||||
case None => analysis.clearHash(path)
|
||||
case Some(hash) => analysis.setHash(path, hash)
|
||||
}
|
||||
}
|
||||
}
|
||||
newHashes.clear()
|
||||
}
|
||||
private def checkClasspath(cp: Iterable[Path])
|
||||
{
|
||||
import scala.collection.mutable.{HashMap, HashSet, Set}
|
||||
val collisions = new HashMap[String, Set[Path]]
|
||||
for(jar <- cp if ClasspathUtilities.isArchive(jar))
|
||||
collisions.getOrElseUpdate(jar.asFile.getName, new HashSet[Path]) += jar
|
||||
for((name, jars) <- collisions)
|
||||
{
|
||||
if(jars.size > 1)
|
||||
{
|
||||
log.warn("Possible duplicate classpath locations for jar " + name + ": ")
|
||||
for(jar <- jars) log.warn("\t" + jar.absolutePath)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected def analysisCallback: AnalysisCallback
|
||||
}
|
||||
object ChangeDetection extends Enumeration
|
||||
{
|
||||
val LastModifiedOnly, HashOnly, HashAndLastModified, HashAndProductsExist = Value
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
/** The trap methods execute the provided code in a try block and handle a thrown exception.*/
|
||||
object Control
|
||||
{
|
||||
def trap[T](errorMessagePrefix: => String, log: Logger)(execute: => Either[String, T]): Either[String, T] =
|
||||
try { execute }
|
||||
catch { case e => log.trace(e); Left(errorMessagePrefix + e.toString) }
|
||||
|
||||
def trapAndFinally[T](errorMessagePrefix: => String, log: Logger)(execute: => Either[String, T])(doFinally: => Unit): Either[String, T] =
|
||||
try { execute }
|
||||
catch { case e => log.trace(e); Left(errorMessagePrefix + e.toString) }
|
||||
finally { trapAndLog(log)(doFinally) }
|
||||
|
||||
def trapUnit(errorMessagePrefix: => String, log: Logger)(execute: => Option[String]): Option[String] =
|
||||
try { execute }
|
||||
catch { case e => log.trace(e); Some(errorMessagePrefix + e.toString) }
|
||||
|
||||
def trapUnitAndFinally(errorMessagePrefix: => String, log: Logger)(execute: => Option[String])(doFinally: => Unit): Option[String] =
|
||||
try { execute }
|
||||
catch { case e => log.trace(e); Some(errorMessagePrefix + e.toString) }
|
||||
finally { trapAndLog(log)(doFinally) }
|
||||
|
||||
def trap(execute: => Unit)
|
||||
{
|
||||
try { execute }
|
||||
catch { case e: Exception => () }
|
||||
}
|
||||
def trapAndLog(log: Logger)(execute: => Unit)
|
||||
{
|
||||
try { execute }
|
||||
catch { case e => log.trace(e); log.error(e.toString) }
|
||||
}
|
||||
def convertException[T](t: => T): Either[Exception, T] =
|
||||
{
|
||||
try { Right(t) }
|
||||
catch { case e: Exception => Left(e) }
|
||||
}
|
||||
def convertErrorMessage[T](log: Logger)(t: => T): Either[String, T] =
|
||||
{
|
||||
try { Right(t) }
|
||||
catch { case e: Exception => log.trace(e); Left(e.toString) }
|
||||
}
|
||||
|
||||
def getOrError[T](result: Either[String, T]): T = result.fold(error, x=>x)
|
||||
final def lazyFold[T](list: List[T])(f: T => Option[String]): Option[String] =
|
||||
list match
|
||||
{
|
||||
case Nil => None
|
||||
case head :: tail =>
|
||||
f(head) match
|
||||
{
|
||||
case None => lazyFold(tail)(f)
|
||||
case x => x
|
||||
}
|
||||
}
|
||||
final def lazyFold[T, S](list: List[T], value: S)(f: (S,T) => Either[String, S]): Either[String, S] =
|
||||
list match
|
||||
{
|
||||
case Nil => Right(value)
|
||||
case head :: tail =>
|
||||
f(value, head) match
|
||||
{
|
||||
case Right(newValue) => lazyFold(tail, newValue)(f)
|
||||
case x => x
|
||||
}
|
||||
}
|
||||
def thread[T](e: Either[String, T])(f: T => Option[String]): Option[String] =
|
||||
e.right.flatMap( t => f(t).toLeft(()) ).left.toOption
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 David MacIver
|
||||
*/
|
||||
package sbt;
|
||||
|
||||
import scala.collection.mutable;
|
||||
|
||||
trait Dag[Node <: Dag[Node]]{
|
||||
self : Node =>
|
||||
|
||||
def dependencies : Iterable[Node]
|
||||
|
||||
def topologicalSort = {
|
||||
val discovered = new mutable.HashSet[Node];
|
||||
val finished = new wrap.MutableSetWrapper(new java.util.LinkedHashSet[Node])
|
||||
|
||||
def visit(dag : Node){
|
||||
if (!discovered(dag)) {
|
||||
discovered(dag) = true;
|
||||
dag.dependencies.foreach(visit);
|
||||
finished += dag;
|
||||
}
|
||||
}
|
||||
|
||||
visit(self);
|
||||
|
||||
finished.toList;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,458 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah, David MacIver
|
||||
*/
|
||||
package sbt
|
||||
|
||||
/** The default project when no project is explicitly configured and the common base class for
|
||||
* configuring a project.*/
|
||||
class DefaultProject(val info: ProjectInfo) extends BasicScalaProject with MavenStyleScalaPaths
|
||||
class DefaultWebProject(val info: ProjectInfo) extends BasicWebScalaProject with MavenStyleWebScalaPaths
|
||||
|
||||
|
||||
import BasicScalaProject._
|
||||
import ScalaProject.{optionsAsString, javaOptionsAsString}
|
||||
import java.io.File
|
||||
import java.util.jar.Attributes
|
||||
|
||||
/** This class defines concrete instances of actions from ScalaProject using overridable paths,
|
||||
* options, and configuration. */
|
||||
abstract class BasicScalaProject extends ScalaProject with BasicDependencyProject with ScalaPaths
|
||||
{
|
||||
/** The explicitly specified class to be run by the 'run' action.
|
||||
* See http://code.google.com/p/simple-build-tool/wiki/RunningProjectCode for details.*/
|
||||
def mainClass: Option[String] = None
|
||||
/** Gets the main class to use. This is used by package and run to determine which main
|
||||
* class to run or include as the Main-Class attribute.
|
||||
* If `mainClass` is explicitly specified, it is used. Otherwise, the main class is selected from
|
||||
* the classes with a main method as automatically detected by the analyzer plugin.
|
||||
* `promptIfMultipleChoices` controls the behavior when multiple main classes are detected.
|
||||
* If true, it prompts the user to select which main class to use. If false, it prints a warning
|
||||
* and returns no main class.*/
|
||||
def getMainClass(promptIfMultipleChoices: Boolean) =
|
||||
mainClass orElse
|
||||
{
|
||||
val applications = mainCompileConditional.analysis.allApplications.toList
|
||||
impl.SelectMainClass(promptIfMultipleChoices, applications) orElse
|
||||
{
|
||||
if(!promptIfMultipleChoices && !applications.isEmpty)
|
||||
warnMultipleMainClasses(log)
|
||||
None
|
||||
}
|
||||
}
|
||||
/** Specifies the value of the `Class-Path` attribute in the manifest of the main jar. */
|
||||
def manifestClassPath: Option[String] = None
|
||||
def dependencies = info.dependencies ++ subProjects.values.toList
|
||||
|
||||
val mainCompileConditional = new CompileConditional(mainCompileConfiguration)
|
||||
val testCompileConditional = new CompileConditional(testCompileConfiguration)
|
||||
|
||||
def compileOrder = CompileOrder.Mixed
|
||||
|
||||
/** The main artifact produced by this project. To redefine the main artifact, override `defaultMainArtifact`
|
||||
* Additional artifacts are defined by `val`s of type `Artifact`.*/
|
||||
lazy val mainArtifact = defaultMainArtifact
|
||||
/** Defines the default main Artifact assigned to `mainArtifact`. By default, this is a jar file with name given
|
||||
* by `artifactID`.*/
|
||||
protected def defaultMainArtifact = Artifact(artifactID, "jar", "jar")
|
||||
|
||||
import Project._
|
||||
|
||||
/** The options provided to the 'compile' action to pass to the Scala compiler.*/
|
||||
def compileOptions: Seq[CompileOption] = Deprecation :: Nil
|
||||
/** The options provided to the 'compile' action to pass to the Java compiler. */
|
||||
def javaCompileOptions: Seq[JavaCompileOption] = Nil
|
||||
/** The options provided to the 'test-compile' action, defaulting to those for the 'compile' action.*/
|
||||
def testCompileOptions: Seq[CompileOption] = compileOptions
|
||||
/** The options provided to the 'test-compile' action to pass to the Java compiler. */
|
||||
def testJavaCompileOptions: Seq[JavaCompileOption] = javaCompileOptions
|
||||
|
||||
/** The options provided to the 'doc' and 'docTest' actions.*/
|
||||
def documentOptions: Seq[ScaladocOption] =
|
||||
LinkSource ::
|
||||
documentTitle(name + " " + version + " API") ::
|
||||
windowTitle(name + " " + version + " API") ::
|
||||
Nil
|
||||
/** The options provided to the 'test' action..*/
|
||||
def testOptions: Seq[TestOption] =
|
||||
TestListeners(testListeners) ::
|
||||
TestFilter(includeTest) ::
|
||||
Nil
|
||||
/** The options provided to the clean action. You can add files to be removed and files to be preserved here.*/
|
||||
def cleanOptions: Seq[CleanOption] =
|
||||
ClearAnalysis(mainCompileConditional.analysis) ::
|
||||
ClearAnalysis(testCompileConditional.analysis) ::
|
||||
historyPath.map(history => Preserve(history)).toList
|
||||
|
||||
def packageOptions: Seq[PackageOption] =
|
||||
manifestClassPath.map(cp => ManifestAttributes( (Attributes.Name.CLASS_PATH, cp) )).toList :::
|
||||
getMainClass(false).map(MainClass(_)).toList
|
||||
|
||||
private def succeededTestPath = testAnalysisPath / "succeeded-tests"
|
||||
private def quickOptions(failedOnly: Boolean) =
|
||||
{
|
||||
val path = succeededTestPath
|
||||
val analysis = testCompileConditional.analysis
|
||||
TestFilter(new impl.TestQuickFilter(analysis, failedOnly, path, log)) :: TestListeners(new impl.TestStatusReporter(path, log) :: Nil) :: Nil
|
||||
}
|
||||
|
||||
protected def includeTest(test: String): Boolean = true
|
||||
|
||||
/** This is called to create the initial directories when a user makes a new project from
|
||||
* sbt.*/
|
||||
override final def initializeDirectories()
|
||||
{
|
||||
FileUtilities.createDirectories(directoriesToCreate.map(_.asFile), log) match
|
||||
{
|
||||
case Some(errorMessage) => log.error("Could not initialize directory structure: " + errorMessage)
|
||||
case None => log.success("Successfully initialized directory structure.")
|
||||
}
|
||||
}
|
||||
import Configurations._
|
||||
/** The managed configuration to use when determining the classpath for a Scala interpreter session.*/
|
||||
def consoleConfiguration = Test
|
||||
|
||||
/** A PathFinder that provides the classpath to pass to scaladoc. It is the same as the compile classpath
|
||||
* by default. */
|
||||
def docClasspath = compileClasspath
|
||||
/** A PathFinder that provides the classpath to pass to the compiler.*/
|
||||
def compileClasspath = fullClasspath(Compile) +++ optionalClasspath
|
||||
/** A PathFinder that provides the classpath to use when unit testing.*/
|
||||
def testClasspath = fullClasspath(Test) +++ optionalClasspath
|
||||
/** A PathFinder that provides the classpath to use when running the class specified by 'getMainClass'.*/
|
||||
def runClasspath = fullClasspath(Runtime) +++ optionalClasspath
|
||||
/** A PathFinder that provides the classpath to use for a Scala interpreter session.*/
|
||||
def consoleClasspath = fullClasspath(consoleConfiguration) +++ optionalClasspath
|
||||
/** A PathFinder that corresponds to Maven's optional scope. It includes any managed libraries in the
|
||||
* 'optional' configuration for this project only.*/
|
||||
def optionalClasspath = managedClasspath(Optional)
|
||||
/** A PathFinder that contains the jars that should be included in a comprehensive package. This is
|
||||
* by default the 'runtime' classpath excluding the 'provided' classpath.*/
|
||||
def publicClasspath = runClasspath --- fullClasspath(Provided)
|
||||
|
||||
/** This returns the unmanaged classpath for only this project for the given configuration. It by
|
||||
* default includes the main compiled classes for this project and the libraries in this project's
|
||||
* unmanaged library directory (lib) and the managed directory for the specified configuration. It
|
||||
* also adds the resource directories appropriate to the configuration.*/
|
||||
def fullUnmanagedClasspath(config: Configuration) =
|
||||
{
|
||||
config match
|
||||
{
|
||||
case CompilerPlugin => unmanagedClasspath
|
||||
case Runtime => runUnmanagedClasspath
|
||||
case Test => testUnmanagedClasspath
|
||||
case _ => mainUnmanagedClasspath
|
||||
}
|
||||
}
|
||||
/** The unmanaged base classpath. By default, the unmanaged classpaths for test and run include this classpath. */
|
||||
protected def mainUnmanagedClasspath = mainCompilePath +++ mainResourceClasspath +++ unmanagedClasspath
|
||||
/** The unmanaged classpath for the run configuration. By default, it includes the base classpath returned by
|
||||
* `mainUnmanagedClasspath`.*/
|
||||
protected def runUnmanagedClasspath = mainUnmanagedClasspath +++ mainDependencies.scalaCompiler
|
||||
/** The unmanaged classpath for the test configuration. By default, it includes the run classpath, which includes the base
|
||||
* classpath returned by `mainUnmanagedClasspath`.*/
|
||||
protected def testUnmanagedClasspath = testCompilePath +++ testResourceClasspath +++ testDependencies.scalaCompiler +++ runUnmanagedClasspath
|
||||
|
||||
/** @deprecated Use `mainDependencies.scalaJars`*/
|
||||
@deprecated protected final def scalaJars: Iterable[File] = mainDependencies.scalaJars.get.map(_.asFile)
|
||||
/** An analysis of the jar dependencies of the main Scala sources. It is only valid after main source compilation.
|
||||
* See the LibraryDependencies class for details. */
|
||||
final def mainDependencies = new LibraryDependencies(this, mainCompileConditional)
|
||||
/** An analysis of the jar dependencies of the test Scala sources. It is only valid after test source compilation.
|
||||
* See the LibraryDependencies class for details. */
|
||||
final def testDependencies = new LibraryDependencies(this, testCompileConditional)
|
||||
|
||||
/** The list of test frameworks to use for testing. Note that adding frameworks to this list
|
||||
* for an active project currently requires an explicit 'clean' to properly update the set of tests to
|
||||
* run*/
|
||||
def testFrameworks: Iterable[TestFramework] = ScalaCheckFramework :: SpecsFramework :: ScalaTestFramework :: Nil
|
||||
/** The list of listeners for testing. */
|
||||
def testListeners: Seq[TestReportListener] = new LogTestReportListener(log) :: Nil
|
||||
|
||||
def mainLabel = "main"
|
||||
def testLabel = "test"
|
||||
|
||||
def mainCompileConfiguration = new MainCompileConfig
|
||||
def testCompileConfiguration = new TestCompileConfig
|
||||
abstract class BaseCompileConfig extends CompileConfiguration
|
||||
{
|
||||
def log = BasicScalaProject.this.log
|
||||
def projectPath = info.projectPath
|
||||
def baseCompileOptions: Seq[CompileOption]
|
||||
lazy val localBaseOptions = baseCompileOptions
|
||||
def options = optionsAsString(localBaseOptions.filter(!_.isInstanceOf[MaxCompileErrors]))
|
||||
def maxErrors = maximumErrors(localBaseOptions)
|
||||
def compileOrder = BasicScalaProject.this.compileOrder
|
||||
}
|
||||
class MainCompileConfig extends BaseCompileConfig
|
||||
{
|
||||
def baseCompileOptions = compileOptions
|
||||
def label = mainLabel
|
||||
def sources = mainSources
|
||||
def outputDirectory = mainCompilePath
|
||||
def classpath = compileClasspath
|
||||
def analysisPath = mainAnalysisPath
|
||||
def testDefinitionClassNames = Nil
|
||||
def javaOptions = javaOptionsAsString(javaCompileOptions)
|
||||
}
|
||||
class TestCompileConfig extends BaseCompileConfig
|
||||
{
|
||||
def baseCompileOptions = testCompileOptions
|
||||
def label = testLabel
|
||||
def sources = testSources
|
||||
def outputDirectory = testCompilePath
|
||||
def classpath = testClasspath
|
||||
def analysisPath = testAnalysisPath
|
||||
def testDefinitionClassNames = testFrameworks.map(_.testSuperClassName)
|
||||
def javaOptions = javaOptionsAsString(testJavaCompileOptions)
|
||||
}
|
||||
|
||||
/** Configures forking the compiler and runner. Use ForkScalaCompiler, ForkScalaRun or mix together.*/
|
||||
def fork: Option[ForkScala] = None
|
||||
private def doCompile(conditional: CompileConditional) =
|
||||
{
|
||||
fork match
|
||||
{
|
||||
case Some(fc: ForkScalaCompiler) => ForkCompile(fc, conditional)
|
||||
case _ => conditional.run
|
||||
}
|
||||
}
|
||||
private def getRunner =
|
||||
{
|
||||
fork match
|
||||
{
|
||||
case Some(fr: ForkScalaRun) => new ForkRun(fr)
|
||||
case _ => Run
|
||||
}
|
||||
}
|
||||
|
||||
protected def compileAction = task { doCompile(mainCompileConditional) } describedAs MainCompileDescription
|
||||
protected def testCompileAction = task { doCompile(testCompileConditional) } dependsOn compile describedAs TestCompileDescription
|
||||
protected def cleanAction = cleanTask(outputPath, cleanOptions) describedAs CleanDescription
|
||||
protected def runAction = task { args => runTask(getMainClass(true), runClasspath, args, getRunner) dependsOn(compile) } describedAs RunDescription
|
||||
protected def consoleQuickAction = consoleTask(consoleClasspath, getRunner) describedAs ConsoleQuickDescription
|
||||
protected def consoleAction = consoleTask(consoleClasspath, getRunner).dependsOn(testCompile) describedAs ConsoleDescription
|
||||
protected def docAction = scaladocTask(mainLabel, mainSources, mainDocPath, docClasspath, documentOptions).dependsOn(compile) describedAs DocDescription
|
||||
protected def docTestAction = scaladocTask(testLabel, testSources, testDocPath, docClasspath, documentOptions).dependsOn(testCompile) describedAs TestDocDescription
|
||||
protected def testAction = defaultTestTask(testOptions)
|
||||
protected def testOnlyAction = testQuickMethod(testCompileConditional.analysis, testOptions)(options =>
|
||||
defaultTestTask(options)) describedAs(TestOnlyDescription)
|
||||
protected def testQuickAction = defaultTestQuickMethod(false) describedAs(TestQuickDescription)
|
||||
protected def testFailedAction = defaultTestQuickMethod(true) describedAs(TestFailedDescription)
|
||||
protected def defaultTestQuickMethod(failedOnly: Boolean) =
|
||||
testQuickMethod(testCompileConditional.analysis, testOptions)(options => defaultTestTask(quickOptions(failedOnly) ::: options.toList))
|
||||
protected def defaultTestTask(testOptions: => Seq[TestOption]) =
|
||||
testTask(testFrameworks, testClasspath, testCompileConditional.analysis, testOptions).dependsOn(testCompile) describedAs TestDescription
|
||||
|
||||
override protected def makePomAction = super.makePomAction dependsOn(`package`)
|
||||
override protected def deliverLocalAction = super.deliverLocalAction dependsOn(`package`)
|
||||
override protected def deliverAction = super.deliverAction dependsOn(`package`)
|
||||
|
||||
protected def packageAction = packageTask(packagePaths, jarPath, packageOptions).dependsOn(compile) describedAs PackageDescription
|
||||
protected def packageTestAction = packageTask(packageTestPaths, packageTestJar).dependsOn(testCompile) describedAs TestPackageDescription
|
||||
protected def packageDocsAction = packageTask(mainDocPath ##, packageDocsJar, Recursive).dependsOn(doc) describedAs DocPackageDescription
|
||||
protected def packageSrcAction = packageTask(packageSourcePaths, packageSrcJar) describedAs SourcePackageDescription
|
||||
protected def packageTestSrcAction = packageTask(packageTestSourcePaths, packageTestSrcJar) describedAs TestSourcePackageDescription
|
||||
protected def packageProjectAction = zipTask(packageProjectPaths, packageProjectZip) describedAs ProjectPackageDescription
|
||||
|
||||
protected def docAllAction = (doc && docTest) describedAs DocAllDescription
|
||||
protected def packageAllAction = task { None } dependsOn(`package`, packageTest, packageSrc, packageTestSrc, packageDocs) describedAs PackageAllDescription
|
||||
protected def graphAction = graphTask(graphPath, mainCompileConditional.analysis).dependsOn(compile)
|
||||
protected def incrementVersionAction = task { incrementVersionNumber(); None } describedAs IncrementVersionDescription
|
||||
protected def releaseAction = (test && packageAll && incrementVersion) describedAs ReleaseDescription
|
||||
|
||||
lazy val compile = compileAction
|
||||
lazy val testCompile = testCompileAction
|
||||
lazy val clean = cleanAction
|
||||
lazy val run = runAction
|
||||
lazy val consoleQuick = consoleQuickAction
|
||||
lazy val console = consoleAction
|
||||
lazy val doc = docAction
|
||||
lazy val docTest = docTestAction
|
||||
lazy val test = testAction
|
||||
lazy val `package` = packageAction
|
||||
lazy val packageTest = packageTestAction
|
||||
lazy val packageDocs = packageDocsAction
|
||||
lazy val packageSrc = packageSrcAction
|
||||
lazy val packageTestSrc = packageTestSrcAction
|
||||
lazy val packageProject = packageProjectAction
|
||||
lazy val docAll = docAllAction
|
||||
lazy val packageAll = packageAllAction
|
||||
lazy val graph = graphAction
|
||||
lazy val incrementVersion = incrementVersionAction
|
||||
lazy val release = releaseAction
|
||||
|
||||
lazy val testQuick = testQuickAction
|
||||
lazy val testFailed = testFailedAction
|
||||
lazy val testOnly = testOnlyAction
|
||||
|
||||
def jarsOfProjectDependencies = Path.lazyPathFinder {
|
||||
topologicalSort.dropRight(1) flatMap { p =>
|
||||
p match
|
||||
{
|
||||
case bpp: BasicScalaPaths => List(bpp.jarPath)
|
||||
case _ => Nil
|
||||
}
|
||||
}
|
||||
}
|
||||
override def deliverScalaDependencies: Iterable[ModuleID] =
|
||||
{
|
||||
val snapshot = mainDependencies.snapshot
|
||||
mapScalaModule(snapshot.scalaLibrary, ManageDependencies.ScalaLibraryID) ++
|
||||
mapScalaModule(snapshot.scalaCompiler, ManageDependencies.ScalaCompilerID)
|
||||
}
|
||||
override def watchPaths = mainSources +++ testSources +++ mainResources +++ testResources
|
||||
}
|
||||
abstract class BasicWebScalaProject extends BasicScalaProject with WebScalaProject with WebScalaPaths
|
||||
{
|
||||
import BasicWebScalaProject._
|
||||
override def watchPaths = super.watchPaths +++ webappResources
|
||||
|
||||
lazy val prepareWebapp = prepareWebappAction
|
||||
protected def prepareWebappAction =
|
||||
prepareWebappTask(webappResources, temporaryWarPath, webappClasspath, mainDependencies.scalaJars) dependsOn(compile)
|
||||
|
||||
def webappClasspath = publicClasspath
|
||||
def jettyRunClasspath = testClasspath
|
||||
def jettyWebappPath = temporaryWarPath
|
||||
lazy val jettyRun = jettyRunAction
|
||||
protected def jettyRunAction =
|
||||
jettyRunTask(jettyWebappPath, jettyContextPath, jettyPort, jettyRunClasspath, "test", scanDirectories.map(_.asFile), scanInterval) dependsOn(prepareWebapp) describedAs(JettyRunDescription)
|
||||
|
||||
/** The directories that should be watched to determine if the web application needs to be reloaded..*/
|
||||
def scanDirectories: Seq[Path] = jettyWebappPath :: Nil
|
||||
/** The time in seconds between scans that check whether the web application should be reloaded.*/
|
||||
def scanInterval: Int = 3
|
||||
/** The port that Jetty runs on. */
|
||||
def jettyPort: Int = JettyRun.DefaultPort
|
||||
|
||||
lazy val jettyRestart = jettyStop && jettyRun
|
||||
lazy val jettyStop = jettyStopAction
|
||||
protected def jettyStopAction = jettyStopTask describedAs(JettyStopDescription)
|
||||
|
||||
/** The clean action for a web project is modified so that it first stops jetty if it is running,
|
||||
* since the webapp directory will be removed by the clean.*/
|
||||
override def cleanAction = super.cleanAction dependsOn jettyStop
|
||||
|
||||
/** Redefine the `package` action to make a war file.*/
|
||||
override protected def packageAction = packageTask(descendents(temporaryWarPath ##, "*"), warPath, Nil) dependsOn(prepareWebapp) describedAs PackageWarDescription
|
||||
|
||||
/** Redefine the default main artifact to be a war file.*/
|
||||
override protected def defaultMainArtifact = Artifact(artifactID, "war", "war")
|
||||
}
|
||||
|
||||
object BasicScalaProject
|
||||
{
|
||||
val CleanDescription =
|
||||
"Deletes all generated files (the target directory)."
|
||||
val MainCompileDescription =
|
||||
"Compiles main sources."
|
||||
val TestCompileDescription =
|
||||
"Compiles test sources."
|
||||
val TestDescription =
|
||||
"Runs all tests detected during compilation."
|
||||
val TestOnlyDescription =
|
||||
"Runs the tests provided as arguments."
|
||||
val TestFailedDescription =
|
||||
"Runs the tests provided as arguments if they have not succeeded."
|
||||
val TestQuickDescription =
|
||||
"Runs the tests provided as arguments if they have not succeeded or their dependencies changed."
|
||||
val DocDescription =
|
||||
"Generates API documentation for main Scala source files using scaladoc."
|
||||
val TestDocDescription =
|
||||
"Generates API documentation for test Scala source files using scaladoc."
|
||||
val RunDescription =
|
||||
"Runs the main class for the project with the provided arguments."
|
||||
val ConsoleDescription =
|
||||
"Starts the Scala interpreter with the project classes on the classpath."
|
||||
val ConsoleQuickDescription =
|
||||
"Starts the Scala interpreter with the project classes on the classpath without running compile first."
|
||||
val PackageDescription =
|
||||
"Creates a jar file containing main classes and resources."
|
||||
val TestPackageDescription =
|
||||
"Creates a jar file containing test classes and resources."
|
||||
val DocPackageDescription =
|
||||
"Creates a jar file containing generated API documentation."
|
||||
val SourcePackageDescription =
|
||||
"Creates a jar file containing all main source files and resources."
|
||||
val TestSourcePackageDescription =
|
||||
"Creates a jar file containing all test source files and resources."
|
||||
val ProjectPackageDescription =
|
||||
"Creates a zip file containing the entire project, excluding generated files."
|
||||
val PackageAllDescription =
|
||||
"Executes all package tasks except package-project."
|
||||
val DocAllDescription =
|
||||
"Generates both main and test documentation."
|
||||
val IncrementVersionDescription =
|
||||
"Increments the micro part of the version (the third number) by one. (This is only valid for versions of the form #.#.#-*)"
|
||||
val ReleaseDescription =
|
||||
"Compiles, tests, generates documentation, packages, and increments the version."
|
||||
|
||||
private def warnMultipleMainClasses(log: Logger) =
|
||||
{
|
||||
log.warn("No Main-Class attribute will be added automatically added:")
|
||||
log.warn("Multiple classes with a main method were detected. Specify main class explicitly with:")
|
||||
log.warn(" override mainClass = Some(\"className\")")
|
||||
}
|
||||
private def mapScalaModule(in: Iterable[_], id: String) =
|
||||
{
|
||||
ScalaVersion.current.toList.flatMap { scalaVersion =>
|
||||
in.map(jar => ModuleID(ManageDependencies.ScalaOrganization, id, scalaVersion))
|
||||
}
|
||||
}
|
||||
}
|
||||
object BasicWebScalaProject
|
||||
{
|
||||
val PackageWarDescription =
|
||||
"Creates a war file."
|
||||
val JettyStopDescription =
|
||||
"Stops the Jetty server that was started with the jetty-run action."
|
||||
val JettyRunDescription =
|
||||
"Starts the Jetty server and serves this project as a web application."
|
||||
}
|
||||
/** Analyzes the dependencies of a project after compilation. All methods except `snapshot` return a
|
||||
* `PathFinder`. The underlying calculations are repeated for each call to PathFinder.get. */
|
||||
final class LibraryDependencies(project: Project, conditional: CompileConditional) extends NotNull
|
||||
{
|
||||
/** Library jars located in unmanaged or managed dependency paths.*/
|
||||
def libraries: PathFinder = pathFinder(snapshot.libraries)
|
||||
/** Library jars located outside of the project.*/
|
||||
def external: PathFinder = pathFinder(snapshot.external)
|
||||
/** The Scala library jar.*/
|
||||
def scalaLibrary: PathFinder = pathFinder(snapshot.scalaLibrary)
|
||||
/** The Scala compiler jar.*/
|
||||
def scalaCompiler: PathFinder = pathFinder(snapshot.scalaCompiler)
|
||||
/** All jar dependencies.*/
|
||||
def all: PathFinder = pathFinder(snapshot.all)
|
||||
/** The Scala library and compiler jars.*/
|
||||
def scalaJars: PathFinder = pathFinder(snapshot.scalaJars)
|
||||
|
||||
/** Returns an object that has all analyzed dependency information frozen at the time of this method call. */
|
||||
def snapshot = new Dependencies
|
||||
|
||||
private def rootProjectDirectory = project.rootProject.info.projectPath
|
||||
|
||||
final class Dependencies
|
||||
{
|
||||
import LibraryDependencies._
|
||||
val all = conditional.analysis.allExternals.filter(ClasspathUtilities.isArchive).map(_.getAbsoluteFile)
|
||||
private[this] val (internal, externalAll) = all.toList.partition(jar => Path.relativize(rootProjectDirectory, jar).isDefined)
|
||||
private[this] val (bootScalaJars, librariesNoScala) = internal.partition(isScalaJar)
|
||||
private[this] val (externalScalaJars, externalNoScala) = externalAll.partition(isScalaJar)
|
||||
val scalaJars = externalScalaJars ::: bootScalaJars
|
||||
val (scalaLibrary, scalaCompiler) = scalaJars.partition(isScalaLibraryJar)
|
||||
def external = externalNoScala
|
||||
def libraries = librariesNoScala
|
||||
}
|
||||
|
||||
private def pathFinder(it: => Iterable[File]) = Path.lazyPathFinder(it.map(Path.fromFile))
|
||||
}
|
||||
private object LibraryDependencies
|
||||
{
|
||||
private def ScalaLibraryPrefix = ManageDependencies.ScalaLibraryID
|
||||
private def ScalaCompilerPrefix = ManageDependencies.ScalaCompilerID
|
||||
private def ScalaJarPrefixes = List(ScalaCompilerPrefix, ScalaLibraryPrefix)
|
||||
private def isScalaJar(file: File) = ClasspathUtilities.isArchive(file) && ScalaJarPrefixes.exists(isNamed(file))
|
||||
private def isScalaLibraryJar(file: File) = isNamed(file)(ScalaLibraryPrefix)
|
||||
private def isNamed(file: File)(name: String) = file.getName.startsWith(name)
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.{File, Writer}
|
||||
|
||||
object DotGraph
|
||||
{
|
||||
def apply(analysis: BasicCompileAnalysis, outputDirectory: Path, log: Logger) =
|
||||
{
|
||||
val outputDir = outputDirectory.asFile
|
||||
|
||||
def generateGraph[Key, Value](fileName: String, graphName: String, graph: Iterable[(Key, scala.collection.Set[Value])],
|
||||
keyToString: Key => String, valueToString: Value => String) =
|
||||
{
|
||||
FileUtilities.write(new File(outputDir, fileName), log)
|
||||
{
|
||||
(writer: Writer) =>
|
||||
{
|
||||
def writeLine(line: String) = FileUtilities.writeLine(writer, line)
|
||||
writeLine("digraph " + graphName + " {")
|
||||
for( (dependsOn, dependants) <- graph; dependant <- dependants)
|
||||
writeLine(valueToString(dependant) + " -> " + keyToString(dependsOn))
|
||||
writeLine("}")
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
FileUtilities.createDirectory(outputDir, log) orElse
|
||||
generateGraph(BasicAnalysis.DependenciesFileName, "dependencies", analysis.allDependencies,
|
||||
sourceToString, sourceToString) orElse
|
||||
generateGraph(BasicAnalysis.ExternalDependenciesFileName, "externalDependencies", analysis.allExternalDependencies,
|
||||
fileToString, sourceToString)
|
||||
}
|
||||
private def sourceToString(source: Path) = fileToString(source.asFile)
|
||||
private def fileToString(file: File) =
|
||||
{
|
||||
val rawName = file.getName
|
||||
val name =
|
||||
if(rawName.endsWith(".scala"))
|
||||
rawName.substring(0, rawName.length - ".scala".length)
|
||||
else
|
||||
rawName
|
||||
"\"" + name + "\""
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,345 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah, David MacIver
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import impl.PropertiesUtilities
|
||||
import scala.reflect.Manifest
|
||||
|
||||
trait Environment
|
||||
{
|
||||
abstract class Property[T] extends NotNull
|
||||
{
|
||||
/** Explicitly sets the value of this property to 'v'.*/
|
||||
def update(v: T): Unit
|
||||
/** Returns the current value of this property or throws an exception if the value could not be obtained.*/
|
||||
def value: T = resolve.value
|
||||
/** Returns the current value of this property in an 'Option'. 'None' is used to indicate that the
|
||||
* value could not obtained.*/
|
||||
def get: Option[T] = resolve.toOption
|
||||
/** Returns full information about this property's current value. */
|
||||
def resolve: PropertyResolution[T]
|
||||
|
||||
def foreach(f: T => Unit): Unit = resolve.foreach(f)
|
||||
}
|
||||
|
||||
/** Creates a system property with the given name and no default value.*/
|
||||
def system[T](propName: String)(implicit format: Format[T]): Property[T]
|
||||
/** Creates a system property with the given name and the given default value to use if no value is explicitly specified.*/
|
||||
def systemOptional[T](propName: String, defaultValue: => T)(implicit format: Format[T]): Property[T]
|
||||
/** Creates a user-defined property that has no default value. The property will try to inherit its value
|
||||
* from a parent environment (if one exists) if its value is not explicitly specified. An explicitly specified
|
||||
* value will persist between builds if the object returned by this method is assigned to a 'val' in this
|
||||
* 'Environment'.*/
|
||||
def property[T](implicit manifest: Manifest[T], format: Format[T]): Property[T]
|
||||
/** Creates a user-defined property that has no default value. The property will try to inherit its value
|
||||
* from a parent environment (if one exists) if its value is not explicitly specified. An explicitly specified
|
||||
* value will persist between builds if the object returned by this method is assigned to a 'val' in this
|
||||
* 'Environment'. The given 'format' is used to convert an instance of 'T' to and from the 'String' representation
|
||||
* used for persistence.*/
|
||||
def propertyF[T](format: Format[T])(implicit manifest: Manifest[T]): Property[T] = property(manifest, format)
|
||||
/** Creates a user-defined property with no default value and no value inheritance from a parent environment.
|
||||
* Its value will persist between builds if the returned object is assigned to a 'val' in this 'Environment'.*/
|
||||
def propertyLocal[T](implicit manifest: Manifest[T], format: Format[T]): Property[T]
|
||||
/** Creates a user-defined property with no default value and no value inheritance from a parent environment.
|
||||
* The property's value will persist between builds if the object returned by this method is assigned to a
|
||||
* 'val' in this 'Environment'. The given 'format' is used to convert an instance of 'T' to and from the
|
||||
* 'String' representation used for persistence.*/
|
||||
def propertyLocalF[T](format: Format[T])(implicit manifest: Manifest[T]): Property[T] = propertyLocal(manifest, format)
|
||||
/** Creates a user-defined property that uses the given default value if no value is explicitly specified for this property. The property's value will persist between builds
|
||||
* if the object returned by this method is assigned to a 'val' in this 'Environment'.*/
|
||||
def propertyOptional[T](defaultValue: => T)(implicit manifest: Manifest[T], format: Format[T]): Property[T]
|
||||
/** Creates a user-defined property with no value inheritance from a parent environment but with the given default
|
||||
* value if no value is explicitly specified for this property. The property's value will persist between builds
|
||||
* if the object returned by this method is assigned to a 'val' in this 'Environment'. The given 'format' is used
|
||||
* to convert an instance of 'T' to and from the 'String' representation used for persistence.*/
|
||||
def propertyOptionalF[T](defaultValue: => T, format: Format[T])(implicit manifest: Manifest[T]): Property[T] =
|
||||
propertyOptional(defaultValue)(manifest, format)
|
||||
}
|
||||
|
||||
import scala.collection.Map
|
||||
trait BasicEnvironment extends Environment
|
||||
{
|
||||
protected def log: Logger
|
||||
/** The location of the properties file that backs the user-defined properties. */
|
||||
def envBackingPath: Path
|
||||
/** The environment from which user-defined properties inherit (if enabled). */
|
||||
protected def parentEnvironment: Option[BasicEnvironment] = None
|
||||
/** The identifier used in messages to refer to this environment. */
|
||||
def environmentLabel = envBackingPath.absolutePath
|
||||
|
||||
private[this] var isModified = false
|
||||
private[sbt] def setEnvironmentModified(modified: Boolean) { synchronized { isModified = modified } }
|
||||
private[this] def isEnvironmentModified = synchronized { isModified }
|
||||
|
||||
|
||||
implicit val IntFormat: Format[Int] = new SimpleFormat[Int] { def fromString(s: String) = java.lang.Integer.parseInt(s) }
|
||||
implicit val LongFormat: Format[Long] = new SimpleFormat[Long] { def fromString(s: String) = java.lang.Long.parseLong(s) }
|
||||
implicit val DoubleFormat: Format[Double] = new SimpleFormat[Double] { def fromString(s: String) = java.lang.Double.parseDouble(s) }
|
||||
implicit val BooleanFormat: Format[Boolean] = new SimpleFormat[Boolean] { def fromString(s: String) = java.lang.Boolean.valueOf(s).booleanValue }
|
||||
implicit val StringFormat: Format[String] = Format.string
|
||||
val NonEmptyStringFormat: Format[String] = new SimpleFormat[String]
|
||||
{
|
||||
def fromString(s: String) =
|
||||
{
|
||||
val trimmed = s.trim
|
||||
if(trimmed.isEmpty)
|
||||
error("The empty string is not allowed.")
|
||||
trimmed
|
||||
}
|
||||
}
|
||||
implicit val VersionFormat: Format[Version] =
|
||||
new SimpleFormat[Version]
|
||||
{
|
||||
def fromString(s: String) = Version.fromString(s).fold(msg => error(msg), x => x)
|
||||
}
|
||||
implicit val FileFormat = Format.file
|
||||
|
||||
|
||||
/** Implementation of 'Property' for user-defined properties. */
|
||||
private[sbt] class UserProperty[T](lazyDefaultValue: => Option[T], format: Format[T], inheritEnabled: Boolean,
|
||||
inheritFirst: Boolean, private[BasicEnvironment] val manifest: Manifest[T]) extends Property[T]
|
||||
{
|
||||
/** The name of this property is used for persistence in the properties file and as an identifier in messages.*/
|
||||
lazy val name = propertyMap.find( p => p._2 eq this ).map(_._1)
|
||||
/** Gets the name of this property or an alternative if the name is not available.*/
|
||||
private def nameString = name.getOrElse("<unnamed>")
|
||||
/** The lazily evaluated default value for this property.*/
|
||||
private lazy val defaultValue = lazyDefaultValue
|
||||
/** The explicitly set value for this property.*/
|
||||
private[BasicEnvironment] var explicitValue =
|
||||
{
|
||||
def initialValue = for(n <- name; stringValue <- initialValues.get(n)) yield format.fromString(stringValue)
|
||||
new LazyVar[Option[T]](initialValue) // ensure propertyMap is initialized before a read occurs
|
||||
}
|
||||
def update(v: T): Unit = synchronized { explicitValue() = Some(v); setEnvironmentModified(true) }
|
||||
def resolve: PropertyResolution[T] =
|
||||
synchronized
|
||||
{
|
||||
if(inheritFirst) resolveInheritFirst
|
||||
else resolveDefaultFirst
|
||||
}
|
||||
private def resolveInheritFirst =
|
||||
explicitValue() match
|
||||
{
|
||||
case Some(v) => DefinedValue(v, false, false)
|
||||
case None =>
|
||||
val inherited = inheritedValue
|
||||
// note that the following means the default value will not be used if an exception occurs inheriting
|
||||
inherited orElse
|
||||
{
|
||||
defaultValue match
|
||||
{
|
||||
case Some(v) => DefinedValue(v, false, true)
|
||||
case None => inherited
|
||||
}
|
||||
}
|
||||
}
|
||||
private def resolveDefaultFirst =
|
||||
(explicitValue() orElse defaultValue) match
|
||||
{
|
||||
case Some(v) => DefinedValue(v, false, explicitValue().isEmpty)
|
||||
case None => inheritedValue
|
||||
}
|
||||
|
||||
private def inheritedValue: PropertyResolution[T] =
|
||||
{
|
||||
val propOption = if(inheritEnabled) parentProperty else None
|
||||
propOption match
|
||||
{
|
||||
case Some(prop) => tryToInherit(prop)
|
||||
case None => UndefinedValue(nameString, environmentLabel)
|
||||
}
|
||||
}
|
||||
private def parentProperty = for(parent <- parentEnvironment; n <- name; prop <- parent.propertyMap.get(n)) yield prop
|
||||
|
||||
private def tryToInherit[R](prop: BasicEnvironment#UserProperty[R]): PropertyResolution[T] =
|
||||
{
|
||||
if(prop.manifest <:< manifest)
|
||||
markInherited(prop.resolve.asInstanceOf[PropertyResolution[T]])
|
||||
else
|
||||
ResolutionException("Could not inherit property '" + nameString + "' from '" + environmentLabel + "':\n" +
|
||||
"\t Property had type " + prop.manifest + ", expected type " + manifest, None)
|
||||
}
|
||||
private def markInherited(result: PropertyResolution[T]) =
|
||||
result match
|
||||
{
|
||||
case DefinedValue(v, isInherited, isDefault) => DefinedValue(v, true, isDefault)
|
||||
case x => x
|
||||
}
|
||||
|
||||
override def toString = nameString + "=" + resolve
|
||||
|
||||
/** Gets the explicitly set value converted to a 'String'.*/
|
||||
private[sbt] def getStringValue: Option[String] = explicitValue().map(format.toString)
|
||||
/** Explicitly sets the value for this property by converting the given string value.*/
|
||||
private[sbt] def setStringValue(s: String) { update(format.fromString(s)) }
|
||||
}
|
||||
/** Implementation of 'Property' for system properties (i.e. System.getProperty/setProperty) */
|
||||
private class SystemProperty[T](val name: String, lazyDefaultValue: => Option[T], val format: Format[T]) extends Property[T]
|
||||
{
|
||||
def resolve =
|
||||
{
|
||||
val rawValue = System.getProperty(name)
|
||||
if(rawValue == null)
|
||||
notFound
|
||||
else
|
||||
{
|
||||
Control.convertException(format.fromString(rawValue)) match
|
||||
{
|
||||
case Left(e) => ResolutionException("Error parsing system property '" + name + "': " + e.toString, Some(e))
|
||||
case Right(x) => DefinedValue(x, false, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Handles resolution when the property has no explicit value. If there is a default value, that is returned,
|
||||
* otherwise, UndefinedValue is returned.*/
|
||||
private def notFound =
|
||||
{
|
||||
defaultValue match
|
||||
{
|
||||
case Some(dv) =>
|
||||
{
|
||||
log.debug("System property '" + name + "' does not exist, using provided default.")
|
||||
DefinedValue(dv, false, true)
|
||||
}
|
||||
case None => UndefinedValue(name, environmentLabel)
|
||||
}
|
||||
}
|
||||
protected lazy val defaultValue = lazyDefaultValue
|
||||
def update(t: T)
|
||||
{
|
||||
for(e <- Control.convertException(System.setProperty(name, format.toString(t))).left)
|
||||
{
|
||||
log.trace(e)
|
||||
log.warn("Error setting system property '" + name + "': " + e.toString)
|
||||
}
|
||||
}
|
||||
override def toString = name + "=" + resolve
|
||||
}
|
||||
|
||||
def system[T](propertyName: String)(implicit format: Format[T]): Property[T] =
|
||||
new SystemProperty[T](propertyName, None, format)
|
||||
def systemOptional[T](propertyName: String, defaultValue: => T)(implicit format: Format[T]): Property[T] =
|
||||
new SystemProperty[T](propertyName, Some(defaultValue), format)
|
||||
|
||||
def property[T](implicit manifest: Manifest[T], format: Format[T]): Property[T] =
|
||||
new UserProperty[T](None, format, true, false, manifest)
|
||||
def propertyLocal[T](implicit manifest: Manifest[T], format: Format[T]): Property[T] =
|
||||
new UserProperty[T](None, format, false, false, manifest)
|
||||
def propertyOptional[T](defaultValue: => T)(implicit manifest: Manifest[T], format: Format[T]): Property[T] =
|
||||
propertyOptional(defaultValue, false)(manifest, format)
|
||||
def propertyOptional[T](defaultValue: => T, inheritFirst: Boolean)(implicit manifest: Manifest[T], format: Format[T]): Property[T] =
|
||||
new UserProperty[T](Some(defaultValue), format, true, inheritFirst, manifest)
|
||||
|
||||
private type AnyUserProperty = UserProperty[_]
|
||||
/** Maps property name to property. The map is constructed by reflecting vals defined on this object,
|
||||
* so it should not be referenced during initialization or else subclass properties will be missed.**/
|
||||
private lazy val propertyMap: Map[String, AnyUserProperty] =
|
||||
{
|
||||
log.debug("Discovering properties")
|
||||
val propertyMap = new scala.collection.mutable.HashMap[String, AnyUserProperty]
|
||||
// AnyProperty is required because the return type of the property*[T] methods is Property[T]
|
||||
// and so the vals we are looking for have type Property[T] and not UserProperty[T]
|
||||
// We then only keep instances of UserProperty
|
||||
val vals = Environment.reflectiveMappings(this, classOf[Property[_]])
|
||||
for( (name, property: AnyUserProperty) <- vals)
|
||||
propertyMap(name) = property
|
||||
propertyMap.readOnly
|
||||
}
|
||||
private val initialValues: Map[String, String] =
|
||||
{
|
||||
val map = new scala.collection.mutable.HashMap[String, String]
|
||||
for(errorMsg <- impl.MapUtilities.read(map, envBackingPath, log))
|
||||
log.error("Error loading properties from " + environmentLabel + " : " + errorMsg)
|
||||
map.readOnly
|
||||
}
|
||||
|
||||
def propertyNames: Iterable[String] = propertyMap.keys.toList
|
||||
def getPropertyNamed(name: String): Option[UserProperty[_]] = propertyMap.get(name)
|
||||
def propertyNamed(name: String): UserProperty[_] = propertyMap(name)
|
||||
def saveEnvironment(): Option[String] =
|
||||
{
|
||||
if(isEnvironmentModified)
|
||||
{
|
||||
val properties = new java.util.Properties
|
||||
for( (name, variable) <- propertyMap; stringValue <- variable.getStringValue)
|
||||
properties.setProperty(name, stringValue)
|
||||
val result = PropertiesUtilities.write(properties, "Project properties", envBackingPath, log)
|
||||
setEnvironmentModified(false)
|
||||
result
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
private[sbt] def uninitializedProperties: Iterable[(String, Property[_])] = propertyMap.filter(_._2.get.isEmpty)
|
||||
}
|
||||
private object Environment
|
||||
{
|
||||
def reflectiveMappings[T](obj: AnyRef, clazz: Class[T]): Map[String, T] =
|
||||
{
|
||||
val mappings = new scala.collection.mutable.OpenHashMap[String, T]
|
||||
for ((name, value) <- ReflectUtilities.allValsC(obj, clazz))
|
||||
mappings(ReflectUtilities.transformCamelCase(name, '.')) = value
|
||||
mappings
|
||||
}
|
||||
}
|
||||
|
||||
sealed trait PropertyResolution[+T] extends NotNull
|
||||
{
|
||||
def value: T
|
||||
def orElse[R >: T](r: => PropertyResolution[R]): PropertyResolution[R]
|
||||
def toOption: Option[T]
|
||||
def foreach(f: T => Unit): Unit
|
||||
def map[R](f: T => R): PropertyResolution[R]
|
||||
def flatMap[R](f: T => PropertyResolution[R]): PropertyResolution[R]
|
||||
}
|
||||
sealed trait NoPropertyValue extends PropertyResolution[Nothing]
|
||||
{ self: RuntimeException with PropertyResolution[Nothing] =>
|
||||
|
||||
def value = throw this
|
||||
def toOption = None
|
||||
def map[R](f: Nothing => R): PropertyResolution[R] = this
|
||||
def flatMap[R](f: Nothing => PropertyResolution[R]): PropertyResolution[R] = this
|
||||
def foreach(f: Nothing => Unit) {}
|
||||
}
|
||||
final case class ResolutionException(message: String, exception: Option[Throwable])
|
||||
extends RuntimeException(message, exception.getOrElse(null)) with NoPropertyValue
|
||||
{
|
||||
def orElse[R](r: => PropertyResolution[R]) = this
|
||||
}
|
||||
final case class UndefinedValue(name: String, environmentLabel: String)
|
||||
extends RuntimeException("Value for property '" + name + "' from " + environmentLabel + " is undefined.") with NoPropertyValue
|
||||
{
|
||||
def orElse[R](r: => PropertyResolution[R]) =
|
||||
r match
|
||||
{
|
||||
case u: UndefinedValue => this
|
||||
case _ => r
|
||||
}
|
||||
}
|
||||
final case class DefinedValue[T](value: T, isInherited: Boolean, isDefault: Boolean) extends PropertyResolution[T]
|
||||
{
|
||||
def toOption = Some(value)
|
||||
def orElse[R >: T](r: => PropertyResolution[R]) = this
|
||||
def map[R](f: T => R) = DefinedValue[R](f(value), isInherited, isDefault)
|
||||
def flatMap[R](f: T => PropertyResolution[R]) = f(value)
|
||||
def foreach(f: T => Unit) { f(value) }
|
||||
}
|
||||
private final class LazyVar[T](initialValue: => T) extends NotNull
|
||||
{
|
||||
private[this] var value: Option[T] = None
|
||||
def apply() =
|
||||
synchronized
|
||||
{
|
||||
value match
|
||||
{
|
||||
case Some(v) => v
|
||||
case None =>
|
||||
val newValue = initialValue
|
||||
value = Some(newValue)
|
||||
newValue
|
||||
}
|
||||
}
|
||||
def update(newValue: T) = synchronized { value = Some(newValue) }
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
/** Defines a function to call as sbt exits.*/
|
||||
trait ExitHook extends NotNull
|
||||
{
|
||||
/** Provides a name for this hook to be used to provide feedback to the user. */
|
||||
def name: String
|
||||
/** Subclasses should implement this method, which is called when this hook is executed. */
|
||||
def runBeforeExiting(): Unit
|
||||
}
|
||||
|
||||
object ExitHooks
|
||||
{
|
||||
/** This is a list of hooks to call when sbt is finished executing.*/
|
||||
private val exitHooks = new scala.collection.mutable.HashSet[ExitHook]
|
||||
/** Adds a hook to call before sbt exits. */
|
||||
private[sbt] def register(hook: ExitHook) { exitHooks += hook }
|
||||
/** Removes a hook. */
|
||||
private[sbt] def unregister(hook: ExitHook) { exitHooks -= hook }
|
||||
/** Calls each registered exit hook, trapping any exceptions so that each hook is given a chance to run. */
|
||||
private[sbt] def runExitHooks(log: Logger)
|
||||
{
|
||||
for(hook <- exitHooks.toList)
|
||||
{
|
||||
try
|
||||
{
|
||||
log.debug("Running exit hook '" + hook.name + "'...")
|
||||
hook.runBeforeExiting()
|
||||
}
|
||||
catch
|
||||
{
|
||||
case e =>
|
||||
{
|
||||
log.trace(e);
|
||||
log.error("Error running exit hook '" + hook.name + "': " + e.toString)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import scala.collection.{mutable, Map, Set}
|
||||
|
||||
sealed trait ProductsSources extends NotNull
|
||||
{
|
||||
def products: Iterable[Path]
|
||||
def sources: Iterable[Path]
|
||||
}
|
||||
sealed trait ProductsWrapper extends NotNull
|
||||
{
|
||||
def from(sources: => Iterable[Path]): ProductsSources = from(Path.lazyPathFinder(sources))
|
||||
def from(sources: PathFinder): ProductsSources
|
||||
}
|
||||
/** Provides methods to define tasks with basic conditional execution based on the sources
|
||||
* and products of the task. */
|
||||
trait FileTasks extends Project
|
||||
{
|
||||
implicit def wrapProduct(product: => Path): ProductsWrapper = FileTasks.wrapProduct(product)
|
||||
implicit def wrapProducts(productsList: => Iterable[Path]): ProductsWrapper = FileTasks.wrapProducts(productsList)
|
||||
/** Runs 'action' if the given products are out of date with respect to the given sources. */
|
||||
def fileTask(label: String, files: ProductsSources)(action: => Option[String]): Task =
|
||||
task { FileTasks.runOption(label, files, log)(action) }
|
||||
/** Runs 'action' if any of the given products do not exist. */
|
||||
def fileTask(label: String, products: => Iterable[Path])(action: => Option[String]): Task =
|
||||
task { FileTasks.existenceCheck[Option[String]](label, products, log)(action)(None) }
|
||||
|
||||
/** Creates a new task that performs 'action' only when the given products are out of date with respect to the given sources.. */
|
||||
def fileTask(files: ProductsSources)(action: => Option[String]): Task = fileTask("", files)(action)
|
||||
/** Creates a new task that performs 'action' only when at least one of the given products does not exist.. */
|
||||
def fileTask(products: => Iterable[Path])(action: => Option[String]): Task = fileTask("", products)(action)
|
||||
|
||||
}
|
||||
object FileTasks
|
||||
{
|
||||
implicit def wrapProduct(product: => Path): ProductsWrapper = wrapProducts(product :: Nil)
|
||||
implicit def wrapProducts(productsList: => Iterable[Path]): ProductsWrapper =
|
||||
new ProductsWrapper
|
||||
{
|
||||
def from(sourceFinder: PathFinder) =
|
||||
new ProductsSources
|
||||
{
|
||||
def products = productsList
|
||||
def sources = sourceFinder.get
|
||||
}
|
||||
}
|
||||
/** Runs 'ifOutofdate' if the given products are out of date with respect to the given sources.*/
|
||||
def runOption(label: String, files: ProductsSources, log: Logger)(ifOutofdate: => Option[String]): Option[String] =
|
||||
{
|
||||
val result = apply[Option[String]](label, files, log)(ifOutofdate)(None)
|
||||
if(result.isDefined)
|
||||
FileUtilities.clean(files.products, true, log)
|
||||
result
|
||||
}
|
||||
/** Returns 'ifOutofdate' if the given products are out of date with respect to the given sources. Otherwise, returns ifUptodate. */
|
||||
def apply[T](label: String, files: ProductsSources, log: Logger)(ifOutofdate: => T)(ifUptodate: => T): T =
|
||||
{
|
||||
val products = files.products
|
||||
existenceCheck[T](label, products, log)(ifOutofdate)
|
||||
{
|
||||
val sources = files.sources
|
||||
if(sources.isEmpty)
|
||||
{
|
||||
log.debug("Running " + label + " task because no sources exist.")
|
||||
ifOutofdate
|
||||
}
|
||||
else
|
||||
{
|
||||
val oldestProductModifiedTime = mapLastModified(products).reduceLeft(_ min _)
|
||||
val newestSourceModifiedTime = mapLastModified(sources).reduceLeft(_ max _)
|
||||
if(oldestProductModifiedTime < newestSourceModifiedTime)
|
||||
{
|
||||
if(log.atLevel(Level.Debug))
|
||||
{
|
||||
log.debug("Running " + label + " task because the following sources are newer than at least one product: ")
|
||||
logDebugIndented(sources.filter(_.lastModified > oldestProductModifiedTime), log)
|
||||
log.debug(" The following products are older than at least one source: ")
|
||||
logDebugIndented(products.filter(_.lastModified < newestSourceModifiedTime), log)
|
||||
}
|
||||
ifOutofdate
|
||||
}
|
||||
else
|
||||
ifUptodate
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Checks that all 'products' exist. If they do, 'ifAllExists' is returned, otherwise 'products' is returned.*/
|
||||
private def existenceCheck[T](label: String, products: Iterable[Path], log: Logger)(action: => T)(ifAllExist: => T) =
|
||||
{
|
||||
val nonexisting = products.filter(!_.exists)
|
||||
if(nonexisting.isEmpty)
|
||||
ifAllExist
|
||||
else
|
||||
{
|
||||
if(log.atLevel(Level.Debug))
|
||||
{
|
||||
log.debug("Running " + label + " task because at least one product does not exist:")
|
||||
logDebugIndented(nonexisting, log)
|
||||
}
|
||||
action
|
||||
}
|
||||
}
|
||||
private def logDebugIndented[T](it: Iterable[T], log: Logger) { it.foreach(x => log.debug("\t" + x)) }
|
||||
private def mapLastModified(paths: Iterable[Path]): Iterable[Long] = paths.map(_.lastModified)
|
||||
}
|
||||
|
|
@ -0,0 +1,892 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah, Nathan Hamblen
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.{Closeable, File, FileInputStream, FileOutputStream, InputStream, OutputStream}
|
||||
import java.io.{ByteArrayOutputStream, InputStreamReader, OutputStreamWriter}
|
||||
import java.io.{BufferedReader, BufferedWriter, FileReader, FileWriter, Reader, Writer}
|
||||
import java.util.zip.{GZIPInputStream, GZIPOutputStream}
|
||||
import java.net.URL
|
||||
import java.nio.charset.{Charset, CharsetDecoder, CharsetEncoder}
|
||||
import java.nio.channels.FileChannel
|
||||
import java.util.jar.{Attributes, JarEntry, JarFile, JarInputStream, JarOutputStream, Manifest}
|
||||
import java.util.zip.{GZIPOutputStream, ZipEntry, ZipFile, ZipInputStream, ZipOutputStream}
|
||||
|
||||
import OpenResource._
|
||||
|
||||
final class Preserved private[sbt](toRestore: scala.collection.Map[File, Path], temp: File) extends NotNull
|
||||
{
|
||||
def restore(log: Logger) =
|
||||
{
|
||||
try
|
||||
{
|
||||
Control.lazyFold(toRestore.toList) { case (src, dest) =>
|
||||
FileUtilities.copyFile(src, dest.asFile, log)
|
||||
}
|
||||
}
|
||||
finally { FileUtilities.clean(Path.fromFile(temp) :: Nil, true, log) }
|
||||
}
|
||||
}
|
||||
|
||||
/** A collection of file related methods. */
|
||||
object FileUtilities
|
||||
{
|
||||
import wrap.Wrappers.readOnly
|
||||
/** The size of the byte or char buffer used in various methods.*/
|
||||
private val BufferSize = 8192
|
||||
private val Newline = System.getProperty("line.separator")
|
||||
/** A pattern used to split a String by path separator characters.*/
|
||||
private val PathSeparatorPattern = java.util.regex.Pattern.compile(File.pathSeparator)
|
||||
|
||||
/** Splits a String around path separator characters. */
|
||||
private[sbt] def pathSplit(s: String) = PathSeparatorPattern.split(s)
|
||||
|
||||
def preserve(paths: Iterable[Path], log: Logger): Either[String, Preserved] =
|
||||
{
|
||||
for(tmp <- createTemporaryDirectory(log).right) yield
|
||||
{
|
||||
val pathMap = new scala.collection.mutable.HashMap[File, Path]
|
||||
val destinationDirectory = Path.fromFile(tmp)
|
||||
for(source <- paths)
|
||||
{
|
||||
val toPath = Path.fromString(destinationDirectory, source.relativePath)
|
||||
copyFile(source, toPath, log)
|
||||
pathMap(toPath.asFile) = source
|
||||
}
|
||||
new Preserved(readOnly(pathMap), tmp)
|
||||
}
|
||||
}
|
||||
|
||||
/** Gzips the file 'in' and writes it to 'out'. 'in' cannot be the same file as 'out'. */
|
||||
def gzip(in: Path, out: Path, log: Logger): Option[String] =
|
||||
{
|
||||
require(in != out, "Input file cannot be the same as the output file.")
|
||||
readStream(in.asFile, log) { inputStream =>
|
||||
writeStream(out.asFile, log) { outputStream =>
|
||||
gzip(inputStream, outputStream, log)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Gzips the InputStream 'in' and writes it to 'output'. Neither stream is closed.*/
|
||||
def gzip(input: InputStream, output: OutputStream, log: Logger): Option[String] =
|
||||
gzipOutputStream.ioOption(output, "gzipping", log) { gzStream => transfer(input, gzStream, log) }
|
||||
|
||||
def gunzip(input: InputStream, output: OutputStream, log: Logger): Option[String] =
|
||||
gzipInputStream.ioOption(input, "gunzipping", log) { gzStream => transfer(gzStream, output, log) }
|
||||
/** Gunzips the file 'in' and writes it to 'out'. 'in' cannot be the same file as 'out'. */
|
||||
def gunzip(in: Path, out: Path, log: Logger): Option[String] =
|
||||
{
|
||||
require(in != out, "Input file cannot be the same as the output file.")
|
||||
readStream(in.asFile, log) { inputStream =>
|
||||
writeStream(out.asFile, log) { outputStream =>
|
||||
gunzip(inputStream, outputStream, log)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Creates a jar file.
|
||||
* @param sources The files to include in the jar file. The path used for the jar is
|
||||
* relative to the base directory for the source. That is, the path in the jar for source
|
||||
* <code>(basePath ##) / x / y</code> is <code>x / y</code>.
|
||||
* @param outputJar The file to write the jar to.
|
||||
* @param manifest The manifest for the jar.
|
||||
* @param recursive If true, any directories in <code>sources</code> are recursively processed. Otherwise,
|
||||
* they are not
|
||||
* @param log The Logger to use. */
|
||||
def jar(sources: Iterable[Path], outputJar: Path, manifest: Manifest, recursive: Boolean, log: Logger) =
|
||||
archive(sources, outputJar, Some(manifest), recursive, log)
|
||||
@deprecated def pack(sources: Iterable[Path], outputJar: Path, manifest: Manifest, recursive: Boolean, log: Logger) =
|
||||
jar(sources, outputJar, manifest, recursive, log)
|
||||
/** Creates a zip file.
|
||||
* @param sources The files to include in the jar file. The path used for the jar is
|
||||
* relative to the base directory for the source. That is, the path in the jar for source
|
||||
* <code>(basePath ##) / x / y</code> is <code>x / y</code>.
|
||||
* @param outputZip The file to write the zip to.
|
||||
* @param recursive If true, any directories in <code>sources</code> are recursively processed. Otherwise,
|
||||
* they are not
|
||||
* @param log The Logger to use. */
|
||||
def zip(sources: Iterable[Path], outputZip: Path, recursive: Boolean, log: Logger) =
|
||||
archive(sources, outputZip, None, recursive, log)
|
||||
|
||||
private def archive(sources: Iterable[Path], outputPath: Path, manifest: Option[Manifest], recursive: Boolean, log: Logger) =
|
||||
{
|
||||
log.info("Packaging " + outputPath + " ...")
|
||||
val outputFile = outputPath.asFile
|
||||
if(outputFile.isDirectory)
|
||||
Some("Specified output file " + outputFile + " is a directory.")
|
||||
else
|
||||
{
|
||||
val outputDir = outputFile.getParentFile
|
||||
val result = createDirectory(outputDir, log) orElse
|
||||
withZipOutput(outputFile, manifest, log)
|
||||
{ output =>
|
||||
val createEntry: (String => ZipEntry) = if(manifest.isDefined) new JarEntry(_) else new ZipEntry(_)
|
||||
writeZip(sources, output, recursive, log)(createEntry)
|
||||
}
|
||||
if(result.isEmpty)
|
||||
log.info("Packaging complete.")
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
private def writeZip(sources: Iterable[Path], output: ZipOutputStream, recursive: Boolean, log: Logger)(createEntry: String => ZipEntry) =
|
||||
{
|
||||
def add(source: Path)
|
||||
{
|
||||
val sourceFile = source.asFile
|
||||
if(sourceFile.isDirectory)
|
||||
{
|
||||
if(recursive)
|
||||
wrapNull(sourceFile.listFiles).foreach(file => add(source / file.getName))
|
||||
}
|
||||
else if(sourceFile.exists)
|
||||
{
|
||||
val relativePath = source.relativePathString("/")
|
||||
log.debug("\tAdding " + source + " as " + relativePath + " ...")
|
||||
val nextEntry = createEntry(relativePath)
|
||||
nextEntry.setTime(sourceFile.lastModified)
|
||||
output.putNextEntry(nextEntry)
|
||||
transferAndClose(new FileInputStream(sourceFile), output, log)
|
||||
}
|
||||
else
|
||||
log.warn("\tSource " + source + " does not exist.")
|
||||
}
|
||||
sources.foreach(add)
|
||||
output.closeEntry()
|
||||
None
|
||||
}
|
||||
|
||||
private def withZipOutput(file: File, manifest: Option[Manifest], log: Logger)(f: ZipOutputStream => Option[String]): Option[String] =
|
||||
{
|
||||
writeStream(file, log)
|
||||
{
|
||||
fileOut =>
|
||||
{
|
||||
val (zipOut, ext) =
|
||||
manifest match
|
||||
{
|
||||
case Some(mf) =>
|
||||
{
|
||||
import Attributes.Name.MANIFEST_VERSION
|
||||
val main = mf.getMainAttributes
|
||||
if(!main.containsKey(MANIFEST_VERSION))
|
||||
main.put(MANIFEST_VERSION, "1.0")
|
||||
(new JarOutputStream(fileOut, mf), "jar")
|
||||
}
|
||||
case None => (new ZipOutputStream(fileOut), "zip")
|
||||
}
|
||||
Control.trapUnitAndFinally("Error writing " + ext + ": ", log)
|
||||
{ f(zipOut) } { zipOut.close }
|
||||
}
|
||||
}
|
||||
}
|
||||
import scala.collection.Set
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
|
||||
def unzip(from: Path, toDirectory: Path, log: Logger): Either[String, Set[Path]] =
|
||||
unzip(from, toDirectory, AllPassFilter, log)
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
|
||||
def unzip(from: File, toDirectory: Path, log: Logger): Either[String, Set[Path]] =
|
||||
unzip(from, toDirectory, AllPassFilter, log)
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
|
||||
def unzip(from: InputStream, toDirectory: Path, log: Logger): Either[String, Set[Path]] =
|
||||
unzip(from, toDirectory, AllPassFilter, log)
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
|
||||
def unzip(from: URL, toDirectory: Path, log: Logger): Either[String, Set[Path]] =
|
||||
unzip(from, toDirectory, AllPassFilter, log)
|
||||
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
|
||||
* Only the entries that match the given filter are extracted. */
|
||||
def unzip(from: Path, toDirectory: Path, filter: NameFilter, log: Logger): Either[String, Set[Path]] =
|
||||
unzip(from.asFile, toDirectory, filter, log)
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
|
||||
* Only the entries that match the given filter are extracted. */
|
||||
def unzip(from: File, toDirectory: Path, filter: NameFilter, log: Logger): Either[String, Set[Path]] =
|
||||
readStreamValue(from, log)(in => unzip(in, toDirectory, filter, log))
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
|
||||
* Only the entries that match the given filter are extracted. */
|
||||
def unzip(from: URL, toDirectory: Path, filter: NameFilter, log: Logger): Either[String, Set[Path]] =
|
||||
readStreamValue(from, log) { stream => unzip(stream, toDirectory, filter, log) }
|
||||
/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
|
||||
* Only the entries that match the given filter are extracted. */
|
||||
def unzip(from: InputStream, toDirectory: Path, filter: NameFilter, log: Logger): Either[String, Set[Path]] =
|
||||
{
|
||||
createDirectory(toDirectory, log) match
|
||||
{
|
||||
case Some(err) => Left(err)
|
||||
case None => zipInputStream.io(from, "unzipping", log) { zipInput => extract(zipInput, toDirectory, filter, log) }
|
||||
}
|
||||
}
|
||||
private def extract(from: ZipInputStream, toDirectory: Path, filter: NameFilter, log: Logger) =
|
||||
{
|
||||
val set = new scala.collection.mutable.HashSet[Path]
|
||||
def next(): Option[String] =
|
||||
{
|
||||
val entry = from.getNextEntry
|
||||
if(entry == null)
|
||||
None
|
||||
else
|
||||
{
|
||||
val name = entry.getName
|
||||
val result =
|
||||
if(filter.accept(name))
|
||||
{
|
||||
val target = Path.fromString(toDirectory, name)
|
||||
log.debug("Extracting zip entry '" + name + "' to '" + target + "'")
|
||||
val result =
|
||||
if(entry.isDirectory)
|
||||
createDirectory(target, log)
|
||||
else
|
||||
{
|
||||
set += target
|
||||
writeStream(target.asFile, log) { out => FileUtilities.transfer(from, out, log) }
|
||||
}
|
||||
//target.asFile.setLastModified(entry.getTime)
|
||||
result
|
||||
}
|
||||
else
|
||||
{
|
||||
log.debug("Ignoring zip entry '" + name + "'")
|
||||
None
|
||||
}
|
||||
from.closeEntry()
|
||||
result match { case None => next(); case x => x }
|
||||
}
|
||||
}
|
||||
next().toLeft(readOnly(set))
|
||||
}
|
||||
|
||||
/** Copies all bytes from the given input stream to the given output stream.
|
||||
* Neither stream is closed.*/
|
||||
def transfer(in: InputStream, out: OutputStream, log: Logger): Option[String] =
|
||||
transferImpl(in, out, false, log)
|
||||
/** Copies all bytes from the given input stream to the given output stream. The
|
||||
* input stream is closed after the method completes.*/
|
||||
def transferAndClose(in: InputStream, out: OutputStream, log: Logger): Option[String] =
|
||||
transferImpl(in, out, true, log)
|
||||
private def transferImpl(in: InputStream, out: OutputStream, close: Boolean, log: Logger): Option[String] =
|
||||
{
|
||||
Control.trapUnitAndFinally("Error during transfer: ", log)
|
||||
{
|
||||
val buffer = new Array[Byte](BufferSize)
|
||||
def read: None.type =
|
||||
{
|
||||
val byteCount = in.read(buffer)
|
||||
if(byteCount >= 0)
|
||||
{
|
||||
out.write(buffer, 0, byteCount)
|
||||
read
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
read
|
||||
}
|
||||
{ if(close) in.close }
|
||||
}
|
||||
|
||||
/** Creates a file at the given location.*/
|
||||
def touch(path: Path, log: Logger): Option[String] = touch(path.asFile, log)
|
||||
/** Creates a file at the given location.*/
|
||||
def touch(file: File, log: Logger): Option[String] =
|
||||
{
|
||||
Control.trapUnit("Could not create file " + file + ": ", log)
|
||||
{
|
||||
if(file.exists)
|
||||
{
|
||||
def updateFailBase = "Could not update last modified for file " + file
|
||||
Control.trapUnit(updateFailBase + ": ", log)
|
||||
{ if(file.setLastModified(System.currentTimeMillis)) None else Some(updateFailBase) }
|
||||
}
|
||||
else
|
||||
createDirectory(file.getParentFile, log) orElse { file.createNewFile(); None }
|
||||
}
|
||||
}
|
||||
/** Creates a directory at the given location.*/
|
||||
def createDirectory(dir: Path, log: Logger): Option[String] = createDirectory(dir.asFile, log)
|
||||
/** Creates a directory at the given location.*/
|
||||
def createDirectory(dir: File, log: Logger): Option[String] =
|
||||
{
|
||||
Control.trapUnit("Could not create directory " + dir + ": ", log)
|
||||
{
|
||||
if(dir.exists)
|
||||
{
|
||||
if(dir.isDirectory)
|
||||
None
|
||||
else
|
||||
Some(dir + " exists and is not a directory.")
|
||||
}
|
||||
else
|
||||
{
|
||||
dir.mkdirs()
|
||||
log.debug("Created directory " + dir)
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Creates directories at the given locations.*/
|
||||
def createDirectories(d: Seq[Path], log: Logger): Option[String] = createDirectories(d.toList.map(_.asFile), log)
|
||||
/** Creates directories at the given locations.*/
|
||||
def createDirectories(d: List[File], log: Logger): Option[String] =
|
||||
d match
|
||||
{
|
||||
case Nil => None
|
||||
case head :: tail => createDirectory(head, log) orElse createDirectories(tail, log)
|
||||
}
|
||||
/** The maximum number of times a unique temporary filename is attempted to be created.*/
|
||||
private val MaximumTries = 10
|
||||
/** Creates a temporary directory and returns it.*/
|
||||
def createTemporaryDirectory(log: Logger): Either[String, File] =
|
||||
{
|
||||
def create(tries: Int): Either[String, File] =
|
||||
{
|
||||
if(tries > MaximumTries)
|
||||
Left("Could not create temporary directory.")
|
||||
else
|
||||
{
|
||||
val randomName = "sbt_" + java.lang.Integer.toHexString(random.nextInt)
|
||||
val f = new File(temporaryDirectory, randomName)
|
||||
|
||||
if(createDirectory(f, log).isEmpty)
|
||||
Right(f)
|
||||
else
|
||||
create(tries + 1)
|
||||
}
|
||||
}
|
||||
create(0)
|
||||
}
|
||||
|
||||
def withTemporaryDirectory(log: Logger)(action: File => Option[String]): Option[String] =
|
||||
doInTemporaryDirectory(log: Logger)(file => action(file).toLeft(())).left.toOption
|
||||
/** Creates a temporary directory and provides its location to the given function. The directory
|
||||
* is deleted after the function returns.*/
|
||||
def doInTemporaryDirectory[T](log: Logger)(action: File => Either[String, T]): Either[String, T] =
|
||||
{
|
||||
def doInDirectory(dir: File): Either[String, T] =
|
||||
{
|
||||
Control.trapAndFinally("", log)
|
||||
{ action(dir) }
|
||||
{ delete(dir, true, log) }
|
||||
}
|
||||
createTemporaryDirectory(log).right.flatMap(doInDirectory)
|
||||
}
|
||||
def withTemporaryFile[T](log: Logger, prefix: String, postfix: String)(action: File => Either[String, T]): Either[String, T] =
|
||||
{
|
||||
Control.trap("Error creating temporary file: ", log)
|
||||
{
|
||||
val file = File.createTempFile(prefix, postfix)
|
||||
Control.trapAndFinally("", log)
|
||||
{ action(file) }
|
||||
{ file.delete() }
|
||||
}
|
||||
}
|
||||
|
||||
/** Copies the files declared in <code>sources</code> to the <code>destinationDirectory</code>
|
||||
* directory. The source directory hierarchy is flattened so that all copies are immediate
|
||||
* children of <code>destinationDirectory</code>. Directories are not recursively entered.*/
|
||||
def copyFlat(sources: Iterable[Path], destinationDirectory: Path, log: Logger) =
|
||||
{
|
||||
val targetSet = new scala.collection.mutable.HashSet[Path]
|
||||
copyImpl(sources, destinationDirectory, log)
|
||||
{
|
||||
source =>
|
||||
{
|
||||
val from = source.asFile
|
||||
val toPath = destinationDirectory / from.getName
|
||||
targetSet += toPath
|
||||
val to = toPath.asFile
|
||||
if(!to.exists || from.lastModified > to.lastModified && !from.isDirectory)
|
||||
{
|
||||
log.debug("Copying " + source + " to " + toPath)
|
||||
copyFile(from, to, log)
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
}.toLeft(readOnly(targetSet))
|
||||
}
|
||||
private def copyImpl(sources: Iterable[Path], destinationDirectory: Path, log: Logger)
|
||||
(doCopy: Path => Option[String]): Option[String] =
|
||||
{
|
||||
val target = destinationDirectory.asFile
|
||||
val creationError =
|
||||
if(target.isDirectory)
|
||||
None
|
||||
else
|
||||
createDirectory(target, log)
|
||||
def copy(sources: List[Path]): Option[String] =
|
||||
{
|
||||
sources match
|
||||
{
|
||||
case src :: remaining =>
|
||||
{
|
||||
doCopy(src) match
|
||||
{
|
||||
case None => copy(remaining)
|
||||
case error => error
|
||||
}
|
||||
}
|
||||
case Nil => None
|
||||
}
|
||||
}
|
||||
creationError orElse ( Control.trapUnit("", log) { copy(sources.toList) } )
|
||||
}
|
||||
/** Retrieves the content of the given URL and writes it to the given File. */
|
||||
def download(url: URL, to: File, log: Logger) =
|
||||
{
|
||||
readStream(url, log) { inputStream =>
|
||||
writeStream(to, log) { outputStream =>
|
||||
transfer(inputStream, outputStream, log)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Copies the files declared in <code>sources</code> to the <code>destinationDirectory</code>
|
||||
* directory. Directories are not recursively entered. The destination hierarchy matches the
|
||||
* source paths relative to any base directories. For example:
|
||||
*
|
||||
* A source <code>(basePath ##) / x / y</code> is copied to <code>destinationDirectory / x / y</code>.
|
||||
* */
|
||||
def copy(sources: Iterable[Path], destinationDirectory: Path, log: Logger) =
|
||||
{
|
||||
val targetSet = new scala.collection.mutable.HashSet[Path]
|
||||
copyImpl(sources, destinationDirectory, log)
|
||||
{
|
||||
source =>
|
||||
{
|
||||
val from = source.asFile
|
||||
val toPath = Path.fromString(destinationDirectory, source.relativePath)
|
||||
targetSet += toPath
|
||||
val to = toPath.asFile
|
||||
if(!to.exists || from.lastModified > to.lastModified)
|
||||
{
|
||||
if(from.isDirectory)
|
||||
createDirectory(to, log)
|
||||
else
|
||||
{
|
||||
log.debug("Copying " + source + " to " + toPath)
|
||||
copyFile(from, to, log)
|
||||
}
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
}.toLeft(readOnly(targetSet))
|
||||
}
|
||||
|
||||
/** Copies the files declared in <code>sources</code> to the <code>targetDirectory</code>
|
||||
* directory. The source directory hierarchy is flattened so that all copies are immediate
|
||||
* children of <code>targetDirectory</code>. Directories are not recursively entered.*/
|
||||
def copyFilesFlat(sources: Iterable[File], targetDirectory: Path, log: Logger) =
|
||||
{
|
||||
require(targetDirectory.asFile.isDirectory, "Target '" + targetDirectory + "' is not a directory.")
|
||||
val byName = new scala.collection.mutable.HashMap[String, File]
|
||||
for(source <- sources) byName.put(source.getName, source)
|
||||
val uniquelyNamedSources = byName.values
|
||||
val targetSet = new scala.collection.mutable.HashSet[Path]
|
||||
def copy(source: File): Option[String] =
|
||||
{
|
||||
if(source.isDirectory)
|
||||
copyAll(source.listFiles.toList)
|
||||
else if(source.exists)
|
||||
{
|
||||
val targetPath = targetDirectory / source.getName
|
||||
targetSet += targetPath
|
||||
if(!targetPath.exists || source.lastModified > targetPath.lastModified)
|
||||
{
|
||||
log.debug("Copying " + source + " to " + targetPath)
|
||||
copyFile(source, targetPath.asFile, log)
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
def copyAll(sources: List[File]): Option[String] =
|
||||
sources match
|
||||
{
|
||||
case head :: tail =>
|
||||
copy(head) match
|
||||
{
|
||||
case None => copyAll(tail)
|
||||
case x => x
|
||||
}
|
||||
case Nil => None
|
||||
}
|
||||
|
||||
Control.trap("Error copying files: ", log) { copyAll(uniquelyNamedSources.toList).toLeft(readOnly(targetSet)) }
|
||||
}
|
||||
/** Copies <code>sourceFile</code> to <code>targetFile</code>. If <code>targetFile</code>
|
||||
* exists, it is overwritten. Note that unlike higher level copies in FileUtilities, this
|
||||
* method always performs the copy, even if sourceFile is older than targetFile.*/
|
||||
def copyFile(sourceFile: Path, targetFile: Path, log: Logger): Option[String] =
|
||||
copyFile(sourceFile.asFile, targetFile.asFile, log)
|
||||
/** Copies <code>sourceFile</code> to <code>targetFile</code>. If <code>targetFile</code>
|
||||
* exists, it is overwritten. Note that unlike higher level copies in FileUtilities, this
|
||||
* method always performs the copy, even if sourceFile is older than targetFile.*/
|
||||
def copyFile(sourceFile: File, targetFile: File, log: Logger): Option[String] =
|
||||
{
|
||||
require(sourceFile.exists, "Source file '" + sourceFile.getAbsolutePath + "' does not exist.")
|
||||
require(!sourceFile.isDirectory, "Source file '" + sourceFile.getAbsolutePath + "' is a directory.")
|
||||
readChannel(sourceFile, log)(
|
||||
in => writeChannel(targetFile, log) {
|
||||
out => {
|
||||
val copied = out.transferFrom(in, 0, in.size)
|
||||
if(copied == in.size)
|
||||
None
|
||||
else
|
||||
Some("Could not copy '" + sourceFile + "' to '" + targetFile + "' (" + copied + "/" + in.size + " bytes copied)")
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
/** Synchronizes the contents of the <code>sourceDirectory</code> directory to the
|
||||
* <code>targetDirectory</code> directory.*/
|
||||
def sync(sourceDirectory: Path, targetDirectory: Path, log: Logger): Option[String] =
|
||||
{
|
||||
copy(((sourceDirectory ##) ** AllPassFilter).get, targetDirectory, log).right.flatMap
|
||||
{ copiedTo => prune(targetDirectory, copiedTo, log).toLeft(()) }.left.toOption
|
||||
}
|
||||
def prune(directory: Path, keepOnly: Iterable[Path], log: Logger): Option[String] =
|
||||
{
|
||||
val existing = ((directory ##) ** AllPassFilter).get
|
||||
val toRemove = scala.collection.mutable.HashSet(existing.toSeq: _*)
|
||||
toRemove --= keepOnly
|
||||
if(log.atLevel(Level.Debug))
|
||||
toRemove.foreach(r => log.debug("Pruning " + r))
|
||||
clean(toRemove, true, log)
|
||||
}
|
||||
|
||||
/** Copies the contents of the <code>source</code> directory to the <code>target</code> directory .*/
|
||||
def copyDirectory(source: Path, target: Path, log: Logger): Option[String] =
|
||||
copyDirectory(source.asFile, target.asFile, log)
|
||||
/** Copies the contents of the <code>source</code> directory to the <code>target</code> directory .*/
|
||||
def copyDirectory(source: File, target: File, log: Logger): Option[String] =
|
||||
{
|
||||
require(source.isDirectory, "Source '" + source.getAbsolutePath + "' is not a directory.")
|
||||
require(!target.exists, "Target '" + target.getAbsolutePath + "' already exists.")
|
||||
def copyDirectory(sourceDir: File, targetDir: File): Option[String] =
|
||||
createDirectory(targetDir, log) orElse copyContents(sourceDir, targetDir)
|
||||
def copyContents(sourceDir: File, targetDir: File): Option[String] =
|
||||
sourceDir.listFiles.foldLeft(None: Option[String])
|
||||
{
|
||||
(result, file) =>
|
||||
result orElse
|
||||
{
|
||||
val targetFile = new File(targetDir, file.getName)
|
||||
if(file.isDirectory)
|
||||
copyDirectory(file, targetFile)
|
||||
else
|
||||
copyFile(file, targetFile, log)
|
||||
}
|
||||
}
|
||||
copyDirectory(source, target)
|
||||
}
|
||||
|
||||
|
||||
/** Deletes the given file recursively.*/
|
||||
def clean(file: Path, log: Logger): Option[String] = clean(file :: Nil, log)
|
||||
/** Deletes the given files recursively.*/
|
||||
def clean(files: Iterable[Path], log: Logger): Option[String] = clean(files, false, log)
|
||||
/** Deletes the given files recursively. <code>quiet</code> determines the logging level.
|
||||
* If it is true, each file in <code>files</code> is logged at the <code>info</code> level.
|
||||
* If it is false, the <code>debug</code> level is used.*/
|
||||
def clean(files: Iterable[Path], quiet: Boolean, log: Logger): Option[String] =
|
||||
deleteFiles(files.map(_.asFile), quiet, log)
|
||||
|
||||
private def deleteFiles(files: Iterable[File], quiet: Boolean, log: Logger): Option[String] =
|
||||
((None: Option[String]) /: files)( (result, file) => result orElse delete(file, quiet, log))
|
||||
private def delete(file: File, quiet: Boolean, log: Logger): Option[String] =
|
||||
{
|
||||
def logMessage(message: => String)
|
||||
{
|
||||
log.log(if(quiet) Level.Debug else Level.Info, message)
|
||||
}
|
||||
Control.trapUnit("Error deleting file " + file + ": ", log)
|
||||
{
|
||||
if(file.isDirectory)
|
||||
{
|
||||
logMessage("Deleting directory " + file)
|
||||
deleteFiles(wrapNull(file.listFiles), true, log)
|
||||
file.delete
|
||||
}
|
||||
else if(file.exists)
|
||||
{
|
||||
logMessage("Deleting file " + file)
|
||||
file.delete
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/** Appends the given <code>String content</code> to the provided <code>file</code> using the default encoding.
|
||||
* A new file is created if it does not exist.*/
|
||||
def append(file: File, content: String, log: Logger): Option[String] = append(file, content, Charset.defaultCharset, log)
|
||||
/** Appends the given <code>String content</code> to the provided <code>file</code> using the given encoding.
|
||||
* A new file is created if it does not exist.*/
|
||||
def append(file: File, content: String, charset: Charset, log: Logger): Option[String] =
|
||||
write(file, content, charset, true, log)
|
||||
|
||||
/** Writes the given <code>String content</code> to the provided <code>file</code> using the default encoding.
|
||||
* If the file exists, it is overwritten.*/
|
||||
def write(file: File, content: String, log: Logger): Option[String] = write(file, content, Charset.defaultCharset, log)
|
||||
/** Writes the given <code>String content</code> to the provided <code>file</code> using the given encoding.
|
||||
* If the file already exists, it is overwritten.*/
|
||||
def write(file: File, content: String, charset: Charset, log: Logger): Option[String] =
|
||||
write(file, content, charset, false, log)
|
||||
private def write(file: File, content: String, charset: Charset, append: Boolean, log: Logger): Option[String] =
|
||||
{
|
||||
if(charset.newEncoder.canEncode(content))
|
||||
write(file, charset, append, log) { w => w.write(content); None }
|
||||
else
|
||||
Some("String cannot be encoded by default charset.")
|
||||
}
|
||||
|
||||
/** Opens a <code>Writer</code> on the given file using the default encoding,
|
||||
* passes it to the provided function, and closes the <code>Writer</code>.*/
|
||||
def write(file: File, log: Logger)(f: Writer => Option[String]): Option[String] =
|
||||
write(file, Charset.defaultCharset, log)(f)
|
||||
/** Opens a <code>Writer</code> on the given file using the given encoding,
|
||||
* passes it to the provided function, and closes the <code>Writer</code>.*/
|
||||
def write(file: File, charset: Charset, log: Logger)(f: Writer => Option[String]): Option[String] =
|
||||
write(file, charset, false, log)(f)
|
||||
private def write(file: File, charset: Charset, append: Boolean, log: Logger)(f: Writer => Option[String]): Option[String] =
|
||||
fileWriter(charset, append).ioOption(file, Writing, log)(f)
|
||||
|
||||
/** Opens a <code>Reader</code> on the given file using the default encoding,
|
||||
* passes it to the provided function, and closes the <code>Reader</code>.*/
|
||||
def read(file: File, log: Logger)(f: Reader => Option[String]): Option[String] =
|
||||
read(file, Charset.defaultCharset, log)(f)
|
||||
/** Opens a <code>Reader</code> on the given file using the default encoding,
|
||||
* passes it to the provided function, and closes the <code>Reader</code>.*/
|
||||
def read(file: File, charset: Charset, log: Logger)(f: Reader => Option[String]): Option[String] =
|
||||
fileReader(charset).ioOption(file, Reading, log)(f)
|
||||
/** Opens a <code>Reader</code> on the given file using the default encoding,
|
||||
* passes it to the provided function, and closes the <code>Reader</code>.*/
|
||||
def readValue[R](file: File, log: Logger)(f: Reader => Either[String, R]): Either[String, R] =
|
||||
readValue(file, Charset.defaultCharset, log)(f)
|
||||
/** Opens a <code>Reader</code> on the given file using the given encoding,
|
||||
* passes it to the provided function, and closes the <code>Reader</code>.*/
|
||||
def readValue[R](file: File, charset: Charset, log: Logger)(f: Reader => Either[String, R]): Either[String, R] =
|
||||
fileReader(charset).io(file, Reading, log)(f)
|
||||
|
||||
/** Reads the contents of the given file into a <code>String</code> using the default encoding.
|
||||
* The resulting <code>String</code> is wrapped in <code>Right</code>.*/
|
||||
def readString(file: File, log: Logger): Either[String, String] = readString(file, Charset.defaultCharset, log)
|
||||
/** Reads the contents of the given file into a <code>String</code> using the given encoding.
|
||||
* The resulting <code>String</code> is wrapped in <code>Right</code>.*/
|
||||
def readString(file: File, charset: Charset, log: Logger): Either[String, String] = readValue(file, charset, log)(readString)
|
||||
|
||||
def readString(in: InputStream, log: Logger): Either[String, String] = readString(in, Charset.defaultCharset, log)
|
||||
def readString(in: InputStream, charset: Charset, log: Logger): Either[String, String] =
|
||||
streamReader.io((in, charset), Reading, log)(readString)
|
||||
def readString(in: Reader, log: Logger): Either[String, String] =
|
||||
Control.trapAndFinally("Error reading bytes from reader: ", log)
|
||||
{ readString(in) }
|
||||
{ in.close() }
|
||||
private def readString(in: Reader): Either[String, String] =
|
||||
{
|
||||
val builder = new StringBuilder
|
||||
val buffer = new Array[Char](BufferSize)
|
||||
def readNext()
|
||||
{
|
||||
val read = in.read(buffer, 0, buffer.length)
|
||||
if(read >= 0)
|
||||
{
|
||||
builder.append(buffer, 0, read)
|
||||
readNext()
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
readNext()
|
||||
Right(builder.toString)
|
||||
}
|
||||
/** Appends the given bytes to the given file. */
|
||||
def append(file: File, bytes: Array[Byte], log: Logger): Option[String] =
|
||||
writeBytes(file, bytes, true, log)
|
||||
/** Writes the given bytes to the given file. If the file already exists, it is overwritten.*/
|
||||
def write(file: File, bytes: Array[Byte], log: Logger): Option[String] =
|
||||
writeBytes(file, bytes, false, log)
|
||||
private def writeBytes(file: File, bytes: Array[Byte], append: Boolean, log: Logger): Option[String] =
|
||||
writeStream(file, append, log) { out => out.write(bytes); None }
|
||||
|
||||
/** Reads the entire file into a byte array. */
|
||||
def readBytes(file: File, log: Logger): Either[String, Array[Byte]] = readStreamValue(file, log)(readBytes)
|
||||
def readBytes(in: InputStream, log: Logger): Either[String, Array[Byte]] =
|
||||
Control.trapAndFinally("Error reading bytes from input stream: ", log)
|
||||
{ readBytes(in) }
|
||||
{ in.close() }
|
||||
private def readBytes(in: InputStream): Either[String, Array[Byte]] =
|
||||
{
|
||||
val out = new ByteArrayOutputStream
|
||||
val buffer = new Array[Byte](BufferSize)
|
||||
def readNext()
|
||||
{
|
||||
val read = in.read(buffer)
|
||||
if(read >= 0)
|
||||
{
|
||||
out.write(buffer, 0, read)
|
||||
readNext()
|
||||
}
|
||||
}
|
||||
readNext()
|
||||
Right(out.toByteArray)
|
||||
}
|
||||
|
||||
/** Opens an <code>OutputStream</code> on the given file with append=true and passes the stream
|
||||
* to the provided function. The stream is closed before this function returns.*/
|
||||
def appendStream(file: File, log: Logger)(f: OutputStream => Option[String]): Option[String] =
|
||||
fileOutputStream(true).ioOption(file, Appending, log)(f)
|
||||
/** Opens an <code>OutputStream</code> on the given file and passes the stream
|
||||
* to the provided function. The stream is closed before this function returns.*/
|
||||
def writeStream(file: File, log: Logger)(f: OutputStream => Option[String]): Option[String] =
|
||||
fileOutputStream(false).ioOption(file, Writing, log)(f)
|
||||
private def writeStream(file: File, append: Boolean, log: Logger)(f: OutputStream => Option[String]): Option[String] =
|
||||
if(append) appendStream(file, log)(f) else writeStream(file, log)(f)
|
||||
/** Opens an <code>InputStream</code> on the given file and passes the stream
|
||||
* to the provided function. The stream is closed before this function returns.*/
|
||||
def readStream(file: File, log: Logger)(f: InputStream => Option[String]): Option[String] =
|
||||
fileInputStream.ioOption(file, Reading, log)(f)
|
||||
/** Opens an <code>InputStream</code> on the given file and passes the stream
|
||||
* to the provided function. The stream is closed before this function returns.*/
|
||||
def readStreamValue[R](file: File, log: Logger)(f: InputStream => Either[String, R]): Either[String, R] =
|
||||
fileInputStream.io(file, Reading, log)(f)
|
||||
/** Opens an <code>InputStream</code> on the given <code>URL</code> and passes the stream
|
||||
* to the provided function. The stream is closed before this function returns.*/
|
||||
def readStream(url: URL, log: Logger)(f: InputStream => Option[String]): Option[String] =
|
||||
urlInputStream.ioOption(url, Reading, log)(f)
|
||||
/** Opens an <code>InputStream</code> on the given <code>URL</code> and passes the stream
|
||||
* to the provided function. The stream is closed before this function returns.*/
|
||||
def readStreamValue[R](url: URL, log: Logger)(f: InputStream => Either[String, R]): Either[String, R] =
|
||||
urlInputStream.io(url, Reading, log)(f)
|
||||
|
||||
/** Opens a <code>FileChannel</code> on the given file for writing and passes the channel
|
||||
* to the given function. The channel is closed before this function returns.*/
|
||||
def writeChannel(file: File, log: Logger)(f: FileChannel => Option[String]): Option[String] =
|
||||
fileOutputChannel.ioOption(file, Writing, log)(f)
|
||||
/** Opens a <code>FileChannel</code> on the given file for reading and passes the channel
|
||||
* to the given function. The channel is closed before this function returns.*/
|
||||
def readChannel(file: File, log: Logger)(f: FileChannel => Option[String]): Option[String] =
|
||||
fileInputChannel.ioOption(file, Reading, log)(f)
|
||||
/** Opens a <code>FileChannel</code> on the given file for reading and passes the channel
|
||||
* to the given function. The channel is closed before this function returns.*/
|
||||
def readChannelValue[R](file: File, log: Logger)(f: FileChannel => Either[String, R]): Either[String, R] =
|
||||
fileInputChannel.io(file, Reading, log)(f)
|
||||
|
||||
private[sbt] def wrapNull(a: Array[File]): Array[File] =
|
||||
if(a == null)
|
||||
new Array[File](0)
|
||||
else
|
||||
a
|
||||
|
||||
/** Writes the given string to the writer followed by a newline.*/
|
||||
private[sbt] def writeLine(writer: Writer, line: String)
|
||||
{
|
||||
writer.write(line)
|
||||
writer.write(Newline)
|
||||
}
|
||||
|
||||
/** The directory in which temporary files are placed.*/
|
||||
val temporaryDirectory = new File(System.getProperty("java.io.tmpdir"))
|
||||
def classLocation(cl: Class[_]): URL = cl.getProtectionDomain.getCodeSource.getLocation
|
||||
def classLocationFile(cl: Class[_]): File = new File(classLocation(cl).toURI)
|
||||
def classLocation[T](implicit mf: scala.reflect.Manifest[T]): URL = classLocation(mf.erasure)
|
||||
def classLocationFile[T](implicit mf: scala.reflect.Manifest[T]): File = classLocationFile(mf.erasure)
|
||||
|
||||
/** The location of the jar containing this class.*/
|
||||
lazy val sbtJar: File = classLocationFile(getClass)
|
||||
lazy val scalaLibraryJar: File = classLocationFile[scala.ScalaObject]
|
||||
lazy val scalaCompilerJar: File = classLocationFile[scala.tools.nsc.Settings]
|
||||
|
||||
/** The producer of randomness for unique name generation.*/
|
||||
private val random = new java.util.Random
|
||||
|
||||
private val Reading = "reading"
|
||||
private val Writing = "writing"
|
||||
private val Appending = "appending"
|
||||
}
|
||||
|
||||
private abstract class OpenResource[Source, T] extends NotNull
|
||||
{
|
||||
import OpenResource.{unwrapEither, wrapEither}
|
||||
protected def open(src: Source, log: Logger): Either[String, T]
|
||||
def ioOption(src: Source, op: String, log: Logger)(f: T => Option[String]) =
|
||||
unwrapEither( io(src, op, log)(wrapEither(f)) )
|
||||
def io[R](src: Source, op: String, log: Logger)(f: T => Either[String,R]): Either[String, R] =
|
||||
open(src, log).right flatMap
|
||||
{
|
||||
resource => Control.trapAndFinally("Error " + op + " "+ src + ": ", log)
|
||||
{ f(resource) }
|
||||
{ close(resource) }
|
||||
}
|
||||
protected def close(out: T): Unit
|
||||
}
|
||||
private trait CloseableOpenResource[Source, T <: Closeable] extends OpenResource[Source, T]
|
||||
{
|
||||
protected def close(out: T): Unit = out.close()
|
||||
}
|
||||
import scala.reflect.{Manifest => SManifest}
|
||||
private abstract class WrapOpenResource[Source, T <: Closeable](implicit srcMf: SManifest[Source], targetMf: SManifest[T]) extends CloseableOpenResource[Source, T]
|
||||
{
|
||||
private def label[S](m: SManifest[S]) = m.erasure.getSimpleName
|
||||
protected def open(source: Source): T
|
||||
protected final def open(source: Source, log: Logger): Either[String, T] =
|
||||
Control.trap("Error wrapping " + label(srcMf) + " in " + label(targetMf) + ": ", log) { Right(open(source)) }
|
||||
}
|
||||
private abstract class OpenFile[T] extends OpenResource[File, T]
|
||||
{
|
||||
protected def open(file: File): T
|
||||
protected final def open(file: File, log: Logger): Either[String, T] =
|
||||
{
|
||||
val parent = file.getParentFile
|
||||
if(parent != null)
|
||||
FileUtilities.createDirectory(parent, log)
|
||||
Control.trap("Error opening " + file + ": ", log) { Right(open(file)) }
|
||||
}
|
||||
}
|
||||
private abstract class CloseableOpenFile[T <: Closeable] extends OpenFile[T] with CloseableOpenResource[File, T]
|
||||
private object OpenResource
|
||||
{
|
||||
private def wrapEither[R](f: R => Option[String]): (R => Either[String, Unit]) = (r: R) => f(r).toLeft(())
|
||||
private def unwrapEither(e: Either[String, Unit]): Option[String] = e.left.toOption
|
||||
|
||||
def fileOutputStream(append: Boolean) =
|
||||
new CloseableOpenFile[FileOutputStream] { protected def open(file: File) = new FileOutputStream(file, append) }
|
||||
def fileInputStream = new CloseableOpenFile[FileInputStream]
|
||||
{ protected def open(file: File) = new FileInputStream(file) }
|
||||
def urlInputStream = new CloseableOpenResource[URL, InputStream]
|
||||
{ protected def open(url: URL, log: Logger) = Control.trap("Error opening " + url + ": ", log) { Right(url.openStream) } }
|
||||
def fileOutputChannel = new CloseableOpenFile[FileChannel]
|
||||
{ protected def open(f: File) = (new FileOutputStream(f)).getChannel }
|
||||
def fileInputChannel = new CloseableOpenFile[FileChannel]
|
||||
{ protected def open(f: File) = (new FileInputStream(f)).getChannel }
|
||||
def fileWriter(charset: Charset, append: Boolean) = new CloseableOpenFile[Writer]
|
||||
{ protected def open(f: File) = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f, append), charset)) }
|
||||
def fileReader(charset: Charset) = new CloseableOpenFile[Reader]
|
||||
{ protected def open(f: File) = new BufferedReader(new InputStreamReader(new FileInputStream(f), charset)) }
|
||||
def jarFile(verify: Boolean) = new OpenFile[JarFile]
|
||||
{ protected def open(f: File) = new JarFile(f, verify)
|
||||
override protected def close(j: JarFile) = j.close() }
|
||||
def zipFile = new OpenFile[ZipFile]
|
||||
{ protected def open(f: File) = new ZipFile(f)
|
||||
override protected def close(z: ZipFile) = z.close() }
|
||||
def streamReader = new WrapOpenResource[(InputStream, Charset), Reader]
|
||||
{ protected def open(streamCharset: (InputStream, Charset)) = new InputStreamReader(streamCharset._1, streamCharset._2) }
|
||||
def gzipInputStream = new WrapOpenResource[InputStream, GZIPInputStream]
|
||||
{ protected def open(in: InputStream) = new GZIPInputStream(in) }
|
||||
def zipInputStream = new WrapOpenResource[InputStream, ZipInputStream]
|
||||
{ protected def open(in: InputStream) = new ZipInputStream(in) }
|
||||
def gzipOutputStream = new WrapOpenResource[OutputStream, GZIPOutputStream]
|
||||
{ protected def open(out: OutputStream) = new GZIPOutputStream(out)
|
||||
override protected def close(out: GZIPOutputStream) = out.finish() }
|
||||
def jarOutputStream = new WrapOpenResource[OutputStream, JarOutputStream]
|
||||
{ protected def open(out: OutputStream) = new JarOutputStream(out) }
|
||||
def jarInputStream = new WrapOpenResource[InputStream, JarInputStream]
|
||||
{ protected def open(in: InputStream) = new JarInputStream(in) }
|
||||
def zipEntry(zip: ZipFile) = new CloseableOpenResource[ZipEntry, InputStream] {
|
||||
protected def open(entry: ZipEntry, log: Logger) =
|
||||
Control.trap("Error opening " + entry.getName + " in " + zip + ": ", log) { Right(zip.getInputStream(entry)) }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
|
||||
abstract class ForkJava extends NotNull
|
||||
{
|
||||
def javaHome: Option[File] = None
|
||||
}
|
||||
abstract class ForkScala extends ForkJava
|
||||
{
|
||||
def scalaJars: Iterable[File] = None
|
||||
}
|
||||
trait ForkScalaRun extends ForkScala
|
||||
{
|
||||
def workingDirectory: Option[File] = None
|
||||
def runJVMOptions: Seq[String] = Nil
|
||||
}
|
||||
trait ForkScalaCompiler extends ForkScala
|
||||
{
|
||||
def compileJVMOptions: Seq[String] = Nil
|
||||
}
|
||||
|
||||
import java.lang.{ProcessBuilder => JProcessBuilder}
|
||||
object Fork
|
||||
{
|
||||
private val ScalacMainClass = "scala.tools.nsc.Main"
|
||||
private val ScalaMainClass = "scala.tools.nsc.MainGenericRunner"
|
||||
val java = new ForkJava("java")
|
||||
val javac = new ForkJava("javac")
|
||||
val scala = new ForkScala(ScalaMainClass)
|
||||
val scalac = new ForkScala(ScalacMainClass)
|
||||
|
||||
private def javaCommand(javaHome: Option[File], name: String): File =
|
||||
{
|
||||
val home = javaHome.getOrElse(new File(System.getProperty("java.home")))
|
||||
new File(new File(home, "bin"), name)
|
||||
}
|
||||
final class ForkJava(commandName: String) extends NotNull
|
||||
{
|
||||
def apply(javaHome: Option[File], options: Seq[String], log: Logger): Int =
|
||||
apply(javaHome, options, None, log)
|
||||
def apply(javaHome: Option[File], options: Seq[String], workingDirectory: File, log: Logger): Int =
|
||||
apply(javaHome, options, Some(workingDirectory), log)
|
||||
def apply(javaHome: Option[File], options: Seq[String], workingDirectory: Option[File], log: Logger): Int =
|
||||
apply(javaHome, options, workingDirectory, Map.empty, log)
|
||||
/** env is additional environment variables*/
|
||||
def apply(javaHome: Option[File], options: Seq[String], workingDirectory: Option[File], env: Map[String, String], log: Logger): Int =
|
||||
{
|
||||
val executable = javaCommand(javaHome, commandName).getAbsolutePath
|
||||
val command = (executable :: options.toList).toArray
|
||||
log.debug("Forking java process: " + command.mkString(" ") + workingDirectory.map("\n\tin " + _.getAbsolutePath).getOrElse(""))
|
||||
val builder = new JProcessBuilder(command : _*)
|
||||
workingDirectory.foreach(wd => builder.directory(wd))
|
||||
val environment = builder.environment
|
||||
for( (key, value) <- env )
|
||||
environment.put(key, value)
|
||||
Process(builder) ! log
|
||||
}
|
||||
}
|
||||
final class ForkScala(mainClassName: String) extends NotNull
|
||||
{
|
||||
def apply(javaHome: Option[File], jvmOptions: Seq[String], scalaJars: Iterable[File], arguments: Seq[String], log: Logger): Int =
|
||||
apply(javaHome, jvmOptions, scalaJars, arguments, None, log)
|
||||
def apply(javaHome: Option[File], jvmOptions: Seq[String], scalaJars: Iterable[File], arguments: Seq[String], workingDirectory: File, log: Logger): Int =
|
||||
apply(javaHome, jvmOptions, scalaJars, arguments, Some(workingDirectory), log)
|
||||
def apply(javaHome: Option[File], jvmOptions: Seq[String], scalaJars: Iterable[File], arguments: Seq[String], workingDirectory: Option[File], log: Logger): Int =
|
||||
{
|
||||
val scalaClasspath =
|
||||
if(scalaJars.isEmpty)
|
||||
FileUtilities.scalaLibraryJar :: FileUtilities.scalaCompilerJar :: Nil
|
||||
else
|
||||
scalaJars
|
||||
val scalaClasspathString = "-Xbootclasspath/a:" + scalaClasspath.map(_.getAbsolutePath).mkString(File.pathSeparator)
|
||||
val mainClass = if(mainClassName.isEmpty) Nil else mainClassName :: Nil
|
||||
val options = jvmOptions ++ (scalaClasspathString :: mainClass ::: arguments.toList)
|
||||
Fork.java(javaHome, options, workingDirectory, log)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah, David MacIver
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import scala.collection.mutable.{HashSet, Set}
|
||||
|
||||
trait Format[T] extends NotNull
|
||||
{
|
||||
def toString(t: T): String
|
||||
def fromString(s: String): T
|
||||
}
|
||||
abstract class SimpleFormat[T] extends Format[T]
|
||||
{
|
||||
def toString(t: T) = t.toString
|
||||
}
|
||||
object Format
|
||||
{
|
||||
def path(basePath: Path): Format[Path] = new Format[Path]
|
||||
{
|
||||
def toString(path: Path) = path.relativePath
|
||||
def fromString(s: String) = Path.fromString(basePath, s)
|
||||
}
|
||||
implicit val file: Format[File] = new Format[File]
|
||||
{
|
||||
def toString(file: File) = file.getAbsolutePath
|
||||
def fromString(s: String) = (new File(s)).getAbsoluteFile
|
||||
}
|
||||
implicit val hash: Format[Array[Byte]] = new Format[Array[Byte]]
|
||||
{
|
||||
def toString(hash: Array[Byte]) = Hash.toHex(hash)
|
||||
def fromString(hash: String) = Hash.fromHex(hash)
|
||||
}
|
||||
def set[T](implicit format: Format[T]): Format[Set[T]] = new Format[Set[T]]
|
||||
{
|
||||
def toString(set: Set[T]) = set.toList.map(format.toString).mkString(File.pathSeparator)
|
||||
def fromString(s: String) = (new HashSet[T]) ++ FileUtilities.pathSplit(s).map(_.trim).filter(!_.isEmpty).map(format.fromString)
|
||||
}
|
||||
implicit val string: Format[String] = new SimpleFormat[String] { def fromString(s: String) = s }
|
||||
implicit val test: Format[TestDefinition] = new SimpleFormat[TestDefinition]
|
||||
{
|
||||
def fromString(s: String) = TestParser.parse(s).fold(error, x => x)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.{ByteArrayInputStream, File, InputStream}
|
||||
|
||||
object Hash
|
||||
{
|
||||
private val BufferSize = 8192
|
||||
def toHex(bytes: Array[Byte]): String =
|
||||
{
|
||||
val buffer = new StringBuilder(bytes.length * 2)
|
||||
for(i <- 0 until bytes.length)
|
||||
{
|
||||
val b = bytes(i)
|
||||
val bi: Int = if(b < 0) b + 256 else b
|
||||
buffer append toHex((bi >>> 4).asInstanceOf[Byte])
|
||||
buffer append toHex((bi & 0x0F).asInstanceOf[Byte])
|
||||
}
|
||||
buffer.toString
|
||||
}
|
||||
def fromHex(hex: String): Array[Byte] =
|
||||
{
|
||||
require((hex.length & 1) == 0, "Hex string must have length 2n.")
|
||||
val array = new Array[Byte](hex.length >> 1)
|
||||
for(i <- 0 until hex.length by 2)
|
||||
{
|
||||
val c1 = hex.charAt(i)
|
||||
val c2 = hex.charAt(i+1)
|
||||
array(i >> 1) = ((fromHex(c1) << 4) | fromHex(c2)).asInstanceOf[Byte]
|
||||
}
|
||||
array
|
||||
}
|
||||
/** Calculates the SHA-1 hash of the given String.*/
|
||||
def apply(s: String, log: Logger): Either[String, Array[Byte]] = apply(new ByteArrayInputStream(s.getBytes("UTF-8")), log)
|
||||
/** Calculates the SHA-1 hash of the given file.*/
|
||||
def apply(path: Path, log: Logger): Either[String, Array[Byte]] = apply(path.asFile, log)
|
||||
/** Calculates the SHA-1 hash of the given file.*/
|
||||
def apply(file: File, log: Logger): Either[String, Array[Byte]] =
|
||||
FileUtilities.readStreamValue(file, log) { stream => apply(stream, log) }
|
||||
/** Calculates the SHA-1 hash of the given stream, closing it when finished.*/
|
||||
def apply(stream: InputStream, log: Logger): Either[String, Array[Byte]] =
|
||||
{
|
||||
import java.security.{MessageDigest, DigestInputStream}
|
||||
val digest = MessageDigest.getInstance("SHA")
|
||||
Control.trapAndFinally("Error computing digest: ", log)
|
||||
{
|
||||
val dis = new DigestInputStream(stream, digest)
|
||||
val buffer = new Array[Byte](BufferSize)
|
||||
while(dis.read(buffer) >= 0) {}
|
||||
dis.close()
|
||||
Right(digest.digest)
|
||||
}
|
||||
{ stream.close() }
|
||||
}
|
||||
|
||||
private def toHex(b: Byte): Char =
|
||||
{
|
||||
require(b >= 0 && b <= 15, "Byte " + b + " was not between 0 and 15")
|
||||
if(b < 10)
|
||||
('0'.asInstanceOf[Int] + b).asInstanceOf[Char]
|
||||
else
|
||||
('a'.asInstanceOf[Int] + (b-10)).asInstanceOf[Char]
|
||||
}
|
||||
private def fromHex(c: Char): Int =
|
||||
{
|
||||
val b =
|
||||
if(c >= '0' && c <= '9')
|
||||
(c - '0')
|
||||
else if(c >= 'a' && c <= 'f')
|
||||
(c - 'a') + 10
|
||||
else if(c >= 'A' && c <= 'F')
|
||||
(c - 'A') + 10
|
||||
else
|
||||
throw new RuntimeException("Invalid hex character: '" + c + "'.")
|
||||
b
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Steven Blundy, Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import ScalaProject.{optionsAsString, javaOptionsAsString}
|
||||
|
||||
trait IntegrationTesting extends NotNull
|
||||
{
|
||||
/** Override to provide pre-test setup. */
|
||||
protected def pretests: Option[String] = None
|
||||
/** Override to provide post-test cleanup. */
|
||||
protected def posttests: Option[String] = None
|
||||
}
|
||||
trait ScalaIntegrationTesting extends IntegrationTesting
|
||||
{ self: ScalaProject =>
|
||||
|
||||
protected def integrationTestTask(frameworks: Iterable[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: => Seq[TestOption]) =
|
||||
testTask(frameworks, classpath, analysis, options)
|
||||
}
|
||||
|
||||
trait BasicScalaIntegrationTesting extends BasicIntegrationTesting with MavenStyleIntegrationTestPaths
|
||||
{ self: BasicScalaProject => }
|
||||
/** A fully featured integration testing that may be mixed in with any subclass of <code>BasicScalaProject</code>.
|
||||
* Pre-suite setup and post-suite cleanup are provide by overriding <code>pretests</code> and <code>posttests</code> respectively.*/
|
||||
trait BasicIntegrationTesting extends ScalaIntegrationTesting with IntegrationTestPaths with BasicDependencyProject
|
||||
{
|
||||
self: BasicScalaProject =>
|
||||
|
||||
import BasicScalaIntegrationTesting._
|
||||
|
||||
lazy val integrationTestCompile = integrationTestCompileAction
|
||||
lazy val integrationTest = integrationTestAction
|
||||
|
||||
val integrationTestCompileConditional = new CompileConditional(integrationTestCompileConfiguration)
|
||||
|
||||
protected def integrationTestAction = integrationTestTask(integrationTestFrameworks, integrationTestClasspath, integrationTestCompileConditional.analysis, integrationTestOptions) dependsOn integrationTestCompile describedAs IntegrationTestCompileDescription
|
||||
protected def integrationTestCompileAction = integrationTestCompileTask() dependsOn compile describedAs IntegrationTestDescription
|
||||
|
||||
protected def integrationTestCompileTask() = task{ integrationTestCompileConditional.run }
|
||||
|
||||
def integrationTestOptions: Seq[TestOption] =
|
||||
TestSetup(() => pretests) ::
|
||||
TestCleanup(() => posttests) ::
|
||||
testOptions.toList
|
||||
def integrationTestCompileOptions = testCompileOptions
|
||||
def javaIntegrationTestCompileOptions: Seq[JavaCompileOption] = testJavaCompileOptions
|
||||
|
||||
def integrationTestConfiguration = if(useIntegrationTestConfiguration) Configurations.IntegrationTest else Configurations.Test
|
||||
def integrationTestClasspath = fullClasspath(integrationTestConfiguration) +++ optionalClasspath
|
||||
|
||||
def integrationTestLabel = "integration-test"
|
||||
def integrationTestCompileConfiguration = new IntegrationTestCompileConfig
|
||||
|
||||
protected def integrationTestDependencies = new LibraryDependencies(this, integrationTestCompileConditional)
|
||||
|
||||
def integrationTestFrameworks = testFrameworks
|
||||
override def useIntegrationTestConfiguration = false
|
||||
abstract override def fullUnmanagedClasspath(config: Configuration) =
|
||||
{
|
||||
val superClasspath = super.fullUnmanagedClasspath(config)
|
||||
if(config == integrationTestConfiguration)
|
||||
integrationTestCompilePath +++ integrationTestResourcesPath +++ superClasspath
|
||||
else
|
||||
superClasspath
|
||||
}
|
||||
|
||||
class IntegrationTestCompileConfig extends BaseCompileConfig
|
||||
{
|
||||
def label = integrationTestLabel
|
||||
def sources = integrationTestSources
|
||||
def outputDirectory = integrationTestCompilePath
|
||||
def classpath = integrationTestClasspath
|
||||
def analysisPath = integrationTestAnalysisPath
|
||||
def baseCompileOptions = integrationTestCompileOptions
|
||||
def javaOptions = javaOptionsAsString(javaCompileOptions)
|
||||
def testDefinitionClassNames = integrationTestFrameworks.map(_.testSuperClassName)
|
||||
}
|
||||
}
|
||||
|
||||
object BasicScalaIntegrationTesting
|
||||
{
|
||||
val IntegrationTestCompileDescription = "Compiles integration test sources."
|
||||
val IntegrationTestDescription = "Runs all integration tests detected during compilation."
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
trait LineReader extends NotNull
|
||||
{
|
||||
def readLine(prompt: String): Option[String]
|
||||
}
|
||||
class Completors(val projectAction: String, val projectNames: Iterable[String],
|
||||
val generalCommands: Iterable[String], val propertyActions: Iterable[String],
|
||||
val prefixes: Iterable[String]) extends NotNull
|
||||
import jline.ConsoleReader
|
||||
abstract class JLine extends LineReader
|
||||
{
|
||||
protected[this] val reader: ConsoleReader
|
||||
def readLine(prompt: String) =
|
||||
reader.readLine(prompt) match
|
||||
{
|
||||
case null => None
|
||||
case x => Some(x.trim)
|
||||
}
|
||||
}
|
||||
object SimpleReader extends JLine
|
||||
{
|
||||
protected[this] val reader =
|
||||
{
|
||||
val cr = new ConsoleReader
|
||||
cr.setBellEnabled(false)
|
||||
cr
|
||||
}
|
||||
}
|
||||
class JLineReader(historyPath: Option[Path], completors: Completors, log: Logger) extends JLine
|
||||
{
|
||||
import completors._
|
||||
import jline.{ArgumentCompletor, Completor, MultiCompletor, NullCompletor, SimpleCompletor}
|
||||
|
||||
private val generalCompletor = simpleCompletor(generalCommands)
|
||||
private val projectCompletor = simpleArgumentCompletor(projectAction :: Nil, projectNames)
|
||||
|
||||
private val completor = new MultiCompletor()
|
||||
|
||||
protected[this] val reader =
|
||||
{
|
||||
val cr = new ConsoleReader
|
||||
cr.setBellEnabled(false)
|
||||
for(historyLocation <- historyPath)
|
||||
{
|
||||
val historyFile = historyLocation.asFile
|
||||
Control.trapAndLog(log)
|
||||
{
|
||||
historyFile.getParentFile.mkdirs()
|
||||
cr.getHistory.setHistoryFile(historyFile)
|
||||
}
|
||||
}
|
||||
cr.addCompletor(completor)
|
||||
cr
|
||||
}
|
||||
|
||||
/** Used for a single argument so that the argument can have spaces in it.*/
|
||||
object SingleArgumentDelimiter extends ArgumentCompletor.AbstractArgumentDelimiter
|
||||
{
|
||||
def isDelimiterChar(buffer: String, pos: Int) =
|
||||
(buffer.charAt(pos) == ' ') && buffer.substring(0, pos).trim.indexOf(' ') == -1
|
||||
}
|
||||
|
||||
private def simpleCompletor(completions: Iterable[String]) = new SimpleCompletor(completions.toList.toArray)
|
||||
private def simpleArgumentCompletor(first: Iterable[String], second: Iterable[String]) =
|
||||
singleArgumentCompletor(simpleCompletor(first), simpleCompletor(second))
|
||||
private def singleArgumentCompletor(first: Completor, second: Completor) =
|
||||
{
|
||||
val completors = Array(first, second, new NullCompletor)
|
||||
val c = new ArgumentCompletor(completors, SingleArgumentDelimiter)
|
||||
c.setStrict(true)
|
||||
c
|
||||
}
|
||||
private def repeatedArgumentCompletor(first: Completor, repeat: Completor) =
|
||||
{
|
||||
val c = new ArgumentCompletor(Array(first, repeat))
|
||||
c.setStrict(true)
|
||||
c
|
||||
}
|
||||
|
||||
private def propertyCompletor(propertyNames: Iterable[String]) =
|
||||
simpleArgumentCompletor(propertyActions, propertyNames)
|
||||
private def prefixedCompletor(baseCompletor: Completor) =
|
||||
singleArgumentCompletor(simpleCompletor(prefixes.toList.toArray), baseCompletor)
|
||||
def setVariableCompletions(taskNames: Iterable[String], propertyNames: Iterable[String], extra: Iterable[(String, Iterable[String])] )
|
||||
{
|
||||
import scala.collection.immutable.TreeSet
|
||||
val taskCompletor = simpleCompletor(TreeSet(taskNames.toSeq : _*))
|
||||
val extraCompletors = for( (first, repeat) <- extra) yield repeatedArgumentCompletor(simpleCompletor(first :: Nil), simpleCompletor(repeat))
|
||||
val baseCompletors = generalCompletor :: taskCompletor :: projectCompletor :: propertyCompletor(propertyNames) :: extraCompletors.toList
|
||||
val baseCompletor = new MultiCompletor(baseCompletors.toArray)
|
||||
completor.setCompletors( Array(baseCompletor, prefixedCompletor(baseCompletor)) )
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,337 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import scala.collection.mutable.{Buffer, HashMap, ListBuffer}
|
||||
|
||||
sealed trait LogEvent extends NotNull
|
||||
final class Success(val msg: String) extends LogEvent
|
||||
final class Log(val level: Level.Value, val msg: String) extends LogEvent
|
||||
final class Trace(val exception: Throwable) extends LogEvent
|
||||
final class SetLevel(val newLevel: Level.Value) extends LogEvent
|
||||
final class SetTrace(val enabled: Boolean) extends LogEvent
|
||||
final class ControlEvent(val event: ControlEvent.Value, val msg: String) extends LogEvent
|
||||
|
||||
object ControlEvent extends Enumeration
|
||||
{
|
||||
val Start, Header, Finish = Value
|
||||
}
|
||||
|
||||
abstract class Logger extends NotNull
|
||||
{
|
||||
def getLevel: Level.Value
|
||||
def setLevel(newLevel: Level.Value)
|
||||
def enableTrace(flag: Boolean)
|
||||
def traceEnabled: Boolean
|
||||
|
||||
def atLevel(level: Level.Value) = level.id >= getLevel.id
|
||||
def trace(t: => Throwable): Unit
|
||||
final def debug(message: => String): Unit = log(Level.Debug, message)
|
||||
final def info(message: => String): Unit = log(Level.Info, message)
|
||||
final def warn(message: => String): Unit = log(Level.Warn, message)
|
||||
final def error(message: => String): Unit = log(Level.Error, message)
|
||||
def success(message: => String): Unit
|
||||
def log(level: Level.Value, message: => String): Unit
|
||||
def control(event: ControlEvent.Value, message: => String): Unit
|
||||
|
||||
/** Use this method to ensure calls. */
|
||||
def logAll(events: Seq[LogEvent]): Unit
|
||||
/** Defined in terms of other methods in Logger and should not be called from them. */
|
||||
final def log(event: LogEvent)
|
||||
{
|
||||
event match
|
||||
{
|
||||
case s: Success => success(s.msg)
|
||||
case l: Log => log(l.level, l.msg)
|
||||
case t: Trace => trace(t.exception)
|
||||
case setL: SetLevel => setLevel(setL.newLevel)
|
||||
case setT: SetTrace => enableTrace(setT.enabled)
|
||||
case c: ControlEvent => control(c.event, c.msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Implements the level-setting methods of Logger.*/
|
||||
abstract class BasicLogger extends Logger
|
||||
{
|
||||
private var traceEnabledVar = true
|
||||
private var level: Level.Value = Level.Info
|
||||
def getLevel = level
|
||||
def setLevel(newLevel: Level.Value) { level = newLevel }
|
||||
def enableTrace(flag: Boolean) { traceEnabledVar = flag }
|
||||
def traceEnabled = traceEnabledVar
|
||||
}
|
||||
|
||||
final class SynchronizedLogger(delegate: Logger) extends Logger
|
||||
{
|
||||
def getLevel = { synchronized { delegate.getLevel } }
|
||||
def setLevel(newLevel: Level.Value) { synchronized { delegate.setLevel(newLevel) } }
|
||||
def enableTrace(enabled: Boolean) { synchronized { delegate.enableTrace(enabled) } }
|
||||
def traceEnabled: Boolean = { synchronized { delegate.traceEnabled } }
|
||||
|
||||
def trace(t: => Throwable) { synchronized { delegate.trace(t) } }
|
||||
def log(level: Level.Value, message: => String) { synchronized { delegate.log(level, message) } }
|
||||
def success(message: => String) { synchronized { delegate.success(message) } }
|
||||
def control(event: ControlEvent.Value, message: => String) { synchronized { delegate.control(event, message) } }
|
||||
def logAll(events: Seq[LogEvent]) { synchronized { delegate.logAll(events) } }
|
||||
}
|
||||
|
||||
final class MultiLogger(delegates: List[Logger]) extends BasicLogger
|
||||
{
|
||||
override def setLevel(newLevel: Level.Value)
|
||||
{
|
||||
super.setLevel(newLevel)
|
||||
dispatch(new SetLevel(newLevel))
|
||||
}
|
||||
override def enableTrace(enabled: Boolean)
|
||||
{
|
||||
super.enableTrace(enabled)
|
||||
dispatch(new SetTrace(enabled))
|
||||
}
|
||||
def trace(t: => Throwable) { dispatch(new Trace(t)) }
|
||||
def log(level: Level.Value, message: => String) { dispatch(new Log(level, message)) }
|
||||
def success(message: => String) { dispatch(new Success(message)) }
|
||||
def logAll(events: Seq[LogEvent]) { delegates.foreach(_.logAll(events)) }
|
||||
def control(event: ControlEvent.Value, message: => String) { delegates.foreach(_.control(event, message)) }
|
||||
private def dispatch(event: LogEvent) { delegates.foreach(_.log(event)) }
|
||||
}
|
||||
|
||||
/** A logger that can buffer the logging done on it by currently executing Thread and
|
||||
* then can flush the buffer to the delegate logger provided in the constructor. Use
|
||||
* 'startRecording' to start buffering and then 'play' from to flush the buffer for the
|
||||
* current Thread to the backing logger. The logging level set at the
|
||||
* time a message is originally logged is used, not the level at the time 'play' is
|
||||
* called.
|
||||
*
|
||||
* This class assumes that it is the only client of the delegate logger.
|
||||
*
|
||||
* This logger is thread-safe.
|
||||
* */
|
||||
final class BufferedLogger(delegate: Logger) extends Logger
|
||||
{
|
||||
private[this] val buffers = wrap.Wrappers.weakMap[Thread, Buffer[LogEvent]]
|
||||
/* The recording depth part is to enable a weak nesting of recording calls. When recording is
|
||||
* nested (recordingDepth >= 2), calls to play/playAll add the buffers for worker Threads to the
|
||||
* serial buffer (main Thread) and calls to clear/clearAll clear worker Thread buffers only. */
|
||||
private[this] def recording = recordingDepth > 0
|
||||
private[this] var recordingDepth = 0
|
||||
|
||||
private[this] val mainThread = Thread.currentThread
|
||||
private[this] def getBuffer(key: Thread) = buffers.getOrElseUpdate(key, new ListBuffer[LogEvent])
|
||||
private[this] def buffer = getBuffer(key)
|
||||
private[this] def key = Thread.currentThread
|
||||
private[this] def serialBuffer = getBuffer(mainThread)
|
||||
|
||||
private[this] def inWorker = Thread.currentThread ne mainThread
|
||||
|
||||
/** Enables buffering. */
|
||||
def startRecording() { synchronized { recordingDepth += 1 } }
|
||||
/** Flushes the buffer to the delegate logger for the current thread. This method calls logAll on the delegate
|
||||
* so that the messages are written consecutively. The buffer is cleared in the process. */
|
||||
def play(): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(recordingDepth == 1)
|
||||
delegate.logAll(wrap.Wrappers.readOnly(buffer))
|
||||
else if(recordingDepth > 1 && inWorker)
|
||||
serialBuffer ++= buffer
|
||||
}
|
||||
def playAll(): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(recordingDepth == 1)
|
||||
{
|
||||
for(buffer <- buffers.values)
|
||||
delegate.logAll(wrap.Wrappers.readOnly(buffer))
|
||||
}
|
||||
else if(recordingDepth > 1)
|
||||
{
|
||||
for((key, buffer) <- buffers.toList if key ne mainThread)
|
||||
serialBuffer ++= buffer
|
||||
}
|
||||
}
|
||||
/** Clears buffered events for the current thread. It does not disable buffering. */
|
||||
def clear(): Unit = synchronized { if(recordingDepth == 1 || inWorker) buffers -= key }
|
||||
/** Clears buffered events for all threads and disables buffering. */
|
||||
def stop(): Unit =
|
||||
synchronized
|
||||
{
|
||||
clearAll()
|
||||
if(recordingDepth > 0)
|
||||
recordingDepth -= 1
|
||||
}
|
||||
/** Clears buffered events for all threads. */
|
||||
def clearAll(): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(recordingDepth <= 1)
|
||||
buffers.clear()
|
||||
else
|
||||
{
|
||||
val serial = serialBuffer
|
||||
buffers.clear()
|
||||
buffers(mainThread) = serial
|
||||
}
|
||||
}
|
||||
def runAndFlush[T](f: => T): T =
|
||||
{
|
||||
try { f }
|
||||
finally { play(); clear() }
|
||||
}
|
||||
|
||||
def setLevel(newLevel: Level.Value): Unit =
|
||||
synchronized {
|
||||
if(recording) buffer += new SetLevel(newLevel)
|
||||
delegate.setLevel(newLevel)
|
||||
}
|
||||
def getLevel = synchronized { delegate.getLevel }
|
||||
def traceEnabled = synchronized { delegate.traceEnabled }
|
||||
def enableTrace(flag: Boolean): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(recording) buffer += new SetTrace(flag)
|
||||
delegate.enableTrace(flag)
|
||||
}
|
||||
|
||||
def trace(t: => Throwable): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(traceEnabled)
|
||||
{
|
||||
if(recording) buffer += new Trace(t)
|
||||
else delegate.trace(t)
|
||||
}
|
||||
}
|
||||
def success(message: => String): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(atLevel(Level.Info))
|
||||
{
|
||||
if(recording)
|
||||
buffer += new Success(message)
|
||||
else
|
||||
delegate.success(message)
|
||||
}
|
||||
}
|
||||
def log(level: Level.Value, message: => String): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(atLevel(level))
|
||||
{
|
||||
if(recording)
|
||||
buffer += new Log(level, message)
|
||||
else
|
||||
delegate.log(level, message)
|
||||
}
|
||||
}
|
||||
def logAll(events: Seq[LogEvent]): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(recording)
|
||||
buffer ++= events
|
||||
else
|
||||
delegate.logAll(events)
|
||||
}
|
||||
def control(event: ControlEvent.Value, message: => String): Unit =
|
||||
synchronized
|
||||
{
|
||||
if(atLevel(Level.Info))
|
||||
{
|
||||
if(recording)
|
||||
buffer += new ControlEvent(event, message)
|
||||
else
|
||||
delegate.control(event, message)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
object ConsoleLogger
|
||||
{
|
||||
private def os = System.getProperty("os.name")
|
||||
private def isWindows = os.toLowerCase.indexOf("windows") >= 0
|
||||
private def formatExplicitlyDisabled = java.lang.Boolean.getBoolean("sbt.log.noformat")
|
||||
private val formatEnabled = !(formatExplicitlyDisabled || isWindows)
|
||||
}
|
||||
|
||||
/** A logger that logs to the console. On non-windows systems, the level labels are
|
||||
* colored.
|
||||
*
|
||||
* This logger is not thread-safe.*/
|
||||
class ConsoleLogger extends BasicLogger
|
||||
{
|
||||
import ConsoleLogger.formatEnabled
|
||||
def messageColor(level: Level.Value) = Console.RESET
|
||||
def labelColor(level: Level.Value) =
|
||||
level match
|
||||
{
|
||||
case Level.Error => Console.RED
|
||||
case Level.Warn => Console.YELLOW
|
||||
case _ => Console.RESET
|
||||
}
|
||||
def successLabelColor = Console.GREEN
|
||||
def successMessageColor = Console.RESET
|
||||
override def success(message: => String)
|
||||
{
|
||||
if(atLevel(Level.Info))
|
||||
log(successLabelColor, Level.SuccessLabel, successMessageColor, message)
|
||||
}
|
||||
def trace(t: => Throwable): Unit =
|
||||
System.out.synchronized
|
||||
{
|
||||
if(traceEnabled)
|
||||
t.printStackTrace
|
||||
}
|
||||
def log(level: Level.Value, message: => String)
|
||||
{
|
||||
if(atLevel(level))
|
||||
log(labelColor(level), level.toString, messageColor(level), message)
|
||||
}
|
||||
private def setColor(color: String)
|
||||
{
|
||||
if(formatEnabled)
|
||||
System.out.synchronized { System.out.print(color) }
|
||||
}
|
||||
private def log(labelColor: String, label: String, messageColor: String, message: String): Unit =
|
||||
System.out.synchronized
|
||||
{
|
||||
for(line <- message.split("""\n"""))
|
||||
{
|
||||
setColor(Console.RESET)
|
||||
System.out.print('[')
|
||||
setColor(labelColor)
|
||||
System.out.print(label)
|
||||
setColor(Console.RESET)
|
||||
System.out.print("] ")
|
||||
setColor(messageColor)
|
||||
System.out.print(line)
|
||||
setColor(Console.RESET)
|
||||
System.out.println()
|
||||
}
|
||||
}
|
||||
|
||||
def logAll(events: Seq[LogEvent]) = System.out.synchronized { events.foreach(log) }
|
||||
def control(event: ControlEvent.Value, message: => String)
|
||||
{ log(labelColor(Level.Info), Level.Info.toString, Console.BLUE, message) }
|
||||
}
|
||||
|
||||
/** An enumeration defining the levels available for logging. A level includes all of the levels
|
||||
* with id larger than its own id. For example, Warn (id=3) includes Error (id=4).*/
|
||||
object Level extends Enumeration with NotNull
|
||||
{
|
||||
val Debug = Value(1, "debug")
|
||||
val Info = Value(2, "info")
|
||||
val Warn = Value(3, "warn")
|
||||
val Error = Value(4, "error")
|
||||
/** Defines the label to use for success messages. A success message is logged at the info level but
|
||||
* uses this label. Because the label for levels is defined in this module, the success
|
||||
* label is also defined here. */
|
||||
val SuccessLabel = "success"
|
||||
|
||||
// added because elements was renamed to iterator in 2.8.0 nightly
|
||||
def levels = Debug :: Info :: Warn :: Error :: Nil
|
||||
/** Returns the level with the given name wrapped in Some, or None if no level exists for that name. */
|
||||
def apply(s: String) = levels.find(s == _.toString)
|
||||
/** Same as apply, defined for use in pattern matching. */
|
||||
private[sbt] def unapply(s: String) = apply(s)
|
||||
}
|
||||
|
|
@ -0,0 +1,673 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Steven Blundy, Mark Harrah, David MacIver, Mikko Peltonen
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import scala.collection.immutable.TreeSet
|
||||
|
||||
private trait RunCompleteAction extends NotNull
|
||||
private class Exit(val code: Int) extends RunCompleteAction
|
||||
private object Reload extends RunCompleteAction
|
||||
|
||||
/** This class is the entry point for sbt. If it is given any arguments, it interprets them
|
||||
* as actions, executes the corresponding actions, and exits. If there were no arguments provided,
|
||||
* sbt enters interactive mode.*/
|
||||
object Main
|
||||
{
|
||||
/** The entry point for sbt. If arguments are specified, they are interpreted as actions, executed,
|
||||
* and then the program terminates. If no arguments are specified, the program enters interactive
|
||||
* mode. Call run if you need to run sbt in the same JVM.*/
|
||||
def main(args: Array[String])
|
||||
{
|
||||
val exitCode = run(args)
|
||||
if(exitCode == RebootExitCode)
|
||||
{
|
||||
println("Rebooting is not supported when the sbt loader is not used.")
|
||||
println("Please manually restart sbt.")
|
||||
}
|
||||
System.exit(exitCode)
|
||||
}
|
||||
val RebootExitCode = -1
|
||||
val NormalExitCode = 0
|
||||
val SetupErrorExitCode = 1
|
||||
val SetupDeclinedExitCode = 2
|
||||
val LoadErrorExitCode = 3
|
||||
val UsageErrorExitCode = 4
|
||||
val BuildErrorExitCode = 5
|
||||
def run(args: Array[String]): Int =
|
||||
{
|
||||
val startTime = System.currentTimeMillis
|
||||
Project.loadProject match
|
||||
{
|
||||
case err: LoadSetupError =>
|
||||
println("\n" + err.message)
|
||||
ExitHooks.runExitHooks(Project.bootLogger)
|
||||
SetupErrorExitCode
|
||||
case LoadSetupDeclined =>
|
||||
ExitHooks.runExitHooks(Project.bootLogger)
|
||||
SetupDeclinedExitCode
|
||||
case err: LoadError =>
|
||||
{
|
||||
val log = Project.bootLogger
|
||||
println(err.message)
|
||||
ExitHooks.runExitHooks(log)
|
||||
// Because this is an error that can probably be corrected, prompt user to try again.
|
||||
val line =
|
||||
try { SimpleReader.readLine("\n Hit enter to retry or 'exit' to quit: ") }
|
||||
catch
|
||||
{
|
||||
case e =>
|
||||
log.trace(e)
|
||||
log.error(e.toString)
|
||||
None
|
||||
}
|
||||
line match
|
||||
{
|
||||
case Some(l) => if(!isTerminateAction(l)) run(args) else NormalExitCode
|
||||
case None => LoadErrorExitCode
|
||||
}
|
||||
}
|
||||
case success: LoadSuccess =>
|
||||
{
|
||||
import success.project
|
||||
val doNext: RunCompleteAction =
|
||||
// in interactive mode, fill all undefined properties
|
||||
if(args.length > 0 || fillUndefinedProjectProperties(project.topologicalSort.toList.reverse))
|
||||
startProject(project, args, startTime)
|
||||
else
|
||||
new Exit(NormalExitCode)
|
||||
ExitHooks.runExitHooks(project.log)
|
||||
doNext match
|
||||
{
|
||||
case Reload => run(args)
|
||||
case x: Exit => x.code
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Returns true if the project should be reloaded, false if sbt should exit.*/
|
||||
private def startProject(project: Project, args: Array[String], startTime: Long): RunCompleteAction =
|
||||
{
|
||||
project.log.info("Building project " + project.name + " " + project.version.toString + " using " + project.getClass.getName)
|
||||
val scalaVersionOpt = ScalaVersion.current orElse project.scalaVersion.get
|
||||
for(sbtVersion <- project.sbtVersion.get; scalaVersion <- scalaVersionOpt if !sbtVersion.isEmpty && !scalaVersion.isEmpty)
|
||||
project.log.info(" with sbt " + sbtVersion + " and Scala " + scalaVersion)
|
||||
args match
|
||||
{
|
||||
case Array() =>
|
||||
CrossBuild.load() match
|
||||
{
|
||||
case None =>
|
||||
project.log.info("No actions specified, interactive session started. Execute 'help' for more information.")
|
||||
val doNext = interactive(project)
|
||||
printTime(project, startTime, "session")
|
||||
doNext
|
||||
case Some(cross) =>
|
||||
crossBuildNext(project, cross)
|
||||
new Exit(RebootExitCode)
|
||||
}
|
||||
case CrossBuild(action) =>
|
||||
val exitCode =
|
||||
CrossBuild.load() match
|
||||
{
|
||||
case None => if(startCrossBuild(project, action)) RebootExitCode else BuildErrorExitCode
|
||||
case Some(cross) => if(crossBuildNext(project, cross)) RebootExitCode else NormalExitCode
|
||||
}
|
||||
new Exit(exitCode)
|
||||
case _ =>
|
||||
val exitCode =
|
||||
Control.lazyFold(args.toList)(handleBatchCommand(project)) match
|
||||
{
|
||||
case None => project.log.success("Build completed successfully."); NormalExitCode
|
||||
case Some(errorMessage) =>
|
||||
project.log.error("Error during build" + (if(errorMessage.isEmpty) "." else ": " + errorMessage) )
|
||||
BuildErrorExitCode
|
||||
}
|
||||
printTime(project, startTime, "build")
|
||||
new Exit(exitCode)
|
||||
}
|
||||
}
|
||||
private def crossBuildNext(project: Project, cross: CrossBuild) =
|
||||
{
|
||||
val setScalaVersion = (newVersion: String) => { System.setProperty(ScalaVersion.LiveKey, newVersion); () }
|
||||
val complete =
|
||||
if(handleAction(project, cross.command))
|
||||
cross.versionComplete(setScalaVersion)
|
||||
else
|
||||
cross.error(setScalaVersion)
|
||||
if(complete)
|
||||
printTime(project, cross.startTime, "cross-build")
|
||||
!complete
|
||||
}
|
||||
|
||||
/** The name of the command that loads a console with access to the current project through the variable 'project'.*/
|
||||
val ProjectConsoleAction = "console-project"
|
||||
/** The name of the command that shows the current project and logging level of that project.*/
|
||||
val ShowCurrent = "current"
|
||||
/** The name of the command that shows all available actions.*/
|
||||
val ShowActions = "actions"
|
||||
/** The name of the command that sets the currently active project.*/
|
||||
val ProjectAction = "project"
|
||||
/** The name of the command that shows all available projects.*/
|
||||
val ShowProjectsAction = "projects"
|
||||
/** The list of lowercase command names that may be used to terminate the program.*/
|
||||
val TerminateActions: Iterable[String] = "exit" :: "quit" :: Nil
|
||||
/** The name of the command that sets the value of the property given as its argument.*/
|
||||
val SetAction = "set"
|
||||
/** The name of the command that gets the value of the property given as its argument.*/
|
||||
val GetAction = "get"
|
||||
/** The name of the command that displays the help message. */
|
||||
val HelpAction = "help"
|
||||
/** The command for rebooting sbt. Requires sbt to have been launched by the loader.*/
|
||||
val RebootCommand = "reboot"
|
||||
/** The name of the command that reloads a project. This is useful for when the project definition has changed. */
|
||||
val ReloadAction = "reload"
|
||||
/** The name of the command that toggles logging stacktraces. */
|
||||
val TraceCommand = "trace"
|
||||
/** The name of the command that compiles all sources continuously when they are modified. */
|
||||
val ContinuousCompileCommand = "cc"
|
||||
/** The prefix used to identify a request to execute the remaining input on source changes.*/
|
||||
val ContinuousExecutePrefix = "~"
|
||||
/** The prefix used to identify a request to execute the remaining input across multiple Scala versions.*/
|
||||
val CrossBuildPrefix = "+"
|
||||
/** Error message for when the user tries to prefix an action with CrossBuildPrefix but the loader is not used.*/
|
||||
val CrossBuildUnsupported = "Cross-building is not supported when the loader is not used."
|
||||
|
||||
/** The number of seconds between polling by the continuous compile command.*/
|
||||
val ContinuousCompilePollDelaySeconds = 1
|
||||
|
||||
/** The list of all available commands at the interactive prompt in addition to the tasks defined
|
||||
* by a project.*/
|
||||
protected def interactiveCommands: Iterable[String] = basicCommands.toList ++ logLevels.toList
|
||||
/** The list of logging levels.*/
|
||||
private def logLevels: Iterable[String] = TreeSet.empty[String] ++ Level.levels.map(_.toString)
|
||||
/** The list of all interactive commands other than logging level.*/
|
||||
private def basicCommands: Iterable[String] = TreeSet(ShowProjectsAction, ShowActions, ShowCurrent, HelpAction,
|
||||
RebootCommand, ReloadAction, TraceCommand, ContinuousCompileCommand, ProjectConsoleAction)
|
||||
|
||||
/** Enters interactive mode for the given root project. It uses JLine for tab completion and
|
||||
* history. It returns normally when the user terminates or reloads the interactive session. That is,
|
||||
* it does not call System.exit to quit.
|
||||
**/
|
||||
private def interactive(baseProject: Project): RunCompleteAction =
|
||||
{
|
||||
val projectNames = baseProject.topologicalSort.map(_.name)
|
||||
val prefixes = ContinuousExecutePrefix :: Nil
|
||||
val completors = new Completors(ProjectAction, projectNames, interactiveCommands, List(GetAction, SetAction), prefixes)
|
||||
val reader = new JLineReader(baseProject.historyPath, completors, baseProject.log)
|
||||
def updateTaskCompletions(project: Project)
|
||||
{
|
||||
val methodCompletions = for( (name, method) <- project.methods) yield (name, method.completions)
|
||||
reader.setVariableCompletions(project.taskNames, project.propertyNames, methodCompletions)
|
||||
}
|
||||
|
||||
/** Prompts the user for the next command using 'currentProject' as context.
|
||||
* If the command indicates that the user wishes to terminate or reload the session,
|
||||
* the function returns the appropriate value.
|
||||
* Otherwise, the command is handled and this function is called again
|
||||
* (tail recursively) to prompt for the next command. */
|
||||
def loop(currentProject: Project): RunCompleteAction =
|
||||
{
|
||||
updateTaskCompletions(baseProject) // this is done after every command because the completions could change due to the action invoked
|
||||
reader.readLine("> ") match
|
||||
{
|
||||
case Some(line) =>
|
||||
{
|
||||
val trimmed = line.trim
|
||||
if(trimmed.isEmpty)
|
||||
loop(currentProject)
|
||||
else if(isTerminateAction(trimmed))
|
||||
new Exit(NormalExitCode)
|
||||
else if(ReloadAction == trimmed)
|
||||
Reload
|
||||
else if(RebootCommand == trimmed)
|
||||
new Exit(RebootExitCode)
|
||||
else if(trimmed.startsWith(CrossBuildPrefix))
|
||||
{
|
||||
if(startCrossBuild(currentProject, trimmed.substring(CrossBuildPrefix.length).trim))
|
||||
new Exit(RebootExitCode)
|
||||
else
|
||||
loop(currentProject)
|
||||
}
|
||||
else if(trimmed.startsWith(ProjectAction + " "))
|
||||
{
|
||||
val projectName = trimmed.substring(ProjectAction.length + 1)
|
||||
baseProject.topologicalSort.find(_.name == projectName) match
|
||||
{
|
||||
case Some(newProject) =>
|
||||
{
|
||||
printProject("Set current project to ", newProject)
|
||||
updateTaskCompletions(newProject)
|
||||
loop(newProject)
|
||||
}
|
||||
case None =>
|
||||
{
|
||||
currentProject.log.error("Invalid project name '" + projectName + "' (type 'projects' to list available projects).")
|
||||
loop(currentProject)
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(trimmed == HelpAction)
|
||||
displayInteractiveHelp()
|
||||
else if(trimmed == ShowProjectsAction)
|
||||
baseProject.topologicalSort.foreach(listProject)
|
||||
else if(trimmed.startsWith(SetAction + " "))
|
||||
setProperty(currentProject, trimmed.substring(SetAction.length + 1))
|
||||
else if(trimmed.startsWith(GetAction + " "))
|
||||
getProperty(currentProject, trimmed.substring(GetAction.length + 1))
|
||||
else if(trimmed == ProjectConsoleAction)
|
||||
showResult(Run.projectConsole(currentProject), currentProject.log)
|
||||
else
|
||||
handleInteractiveCommand(currentProject, trimmed)
|
||||
loop(currentProject)
|
||||
}
|
||||
}
|
||||
case None => new Exit(NormalExitCode)
|
||||
}
|
||||
}
|
||||
|
||||
loop(baseProject)
|
||||
}
|
||||
private def printCmd(name:String, desc:String) = Console.println("\t" + name + ": " + desc)
|
||||
private def displayBatchHelp() = {
|
||||
Console.println("You may execute any project action or method or one of the commands described below.")
|
||||
Console.println("Available Commands:")
|
||||
printCommonCommands()
|
||||
}
|
||||
private def printCommonCommands()
|
||||
{
|
||||
printCmd("<action name>", "Executes the project specified action.")
|
||||
printCmd("<method name> <parameter>*", "Executes the project specified method.")
|
||||
printCmd(ContinuousExecutePrefix + " <command>", "Executes the project specified action or method whenever source files change.")
|
||||
printCmd(CrossBuildPrefix + " <command>", "Executes the project specified action or method for all versions of Scala defined in crossScalaVersions.")
|
||||
printCmd(ShowActions, "Shows all available actions.")
|
||||
printCmd(RebootCommand, "Changes to scala.version or sbt.version are processed and the project definition is reloaded.")
|
||||
printCmd(HelpAction, "Displays this help message.")
|
||||
}
|
||||
private def displayInteractiveHelp() = {
|
||||
Console.println("You may execute any project action or one of the commands described below. Only one action " +
|
||||
"may be executed at a time in interactive mode and is entered by name, as it would be at the command line." +
|
||||
" Also, tab completion is available.")
|
||||
Console.println("Available Commands:")
|
||||
|
||||
printCommonCommands()
|
||||
printCmd(ReloadAction, "Reloads sbt, recompiling modified project definitions if necessary.")
|
||||
printCmd(ShowCurrent, "Shows the current project and logging level of that project.")
|
||||
printCmd(Level.levels.mkString(", "), "Set logging for the current project to the specified level.")
|
||||
printCmd(TraceCommand, "Toggles whether logging stack traces is enabled.")
|
||||
printCmd(ProjectAction + " <project name>", "Sets the currently active project.")
|
||||
printCmd(ShowProjectsAction, "Shows all available projects.")
|
||||
printCmd(TerminateActions.elements.mkString(", "), "Terminates the program.")
|
||||
printCmd(SetAction + " <property> <value>", "Sets the value of the property given as its argument.")
|
||||
printCmd(GetAction + " <property>", "Gets the value of the property given as its argument.")
|
||||
printCmd(ProjectConsoleAction, "Enters the Scala interpreter with the current project bound to the variable 'current' and all members imported.")
|
||||
}
|
||||
private def listProject(p: Project) = printProject("\t", p)
|
||||
private def printProject(prefix: String, p: Project): Unit =
|
||||
Console.println(prefix + p.name + " " + p.version)
|
||||
|
||||
private def startCrossBuild(project: Project, action: String) =
|
||||
{
|
||||
checkBooted && checkAction(project, action) &&
|
||||
{
|
||||
val againstScalaVersions = project.crossScalaVersions
|
||||
val versionsDefined = !againstScalaVersions.isEmpty
|
||||
if(versionsDefined)
|
||||
CrossBuild(againstScalaVersions, action, System.currentTimeMillis)
|
||||
else
|
||||
Console.println("Project does not declare any Scala versions to cross-build against.")
|
||||
versionsDefined
|
||||
}
|
||||
}
|
||||
private def checkBooted =
|
||||
Project.booted ||
|
||||
{
|
||||
Console.println(CrossBuildUnsupported)
|
||||
false
|
||||
}
|
||||
|
||||
/** Handles the given command string provided by batch mode execution..*/
|
||||
private def handleBatchCommand(project: Project)(command: String): Option[String] =
|
||||
{
|
||||
command.trim match
|
||||
{
|
||||
case HelpAction => displayBatchHelp(); None
|
||||
case ShowActions => showActions(project); None
|
||||
case CrossBuild(crossBuildAction) => Some(CrossBuildUnsupported)
|
||||
case action => if(handleAction(project, action)) None else Some("")
|
||||
}
|
||||
}
|
||||
|
||||
/** Handles the given command string provided at the command line.*/
|
||||
private def handleInteractiveCommand(project: Project, command: String)
|
||||
{
|
||||
command match
|
||||
{
|
||||
case GetAction => getArgumentError(project.log)
|
||||
case SetAction => setArgumentError(project.log)
|
||||
case ProjectAction => setProjectError(project.log)
|
||||
case ShowCurrent =>
|
||||
printProject("Current project is ", project)
|
||||
Console.println("Current log level is " + project.log.getLevel)
|
||||
printTraceEnabled(project)
|
||||
case ShowActions => showActions(project)
|
||||
case TraceCommand => toggleTrace(project)
|
||||
case Level(level) => setLevel(project, level)
|
||||
case ContinuousCompileCommand => compileContinuously(project)
|
||||
case action if action.startsWith(ContinuousExecutePrefix) =>
|
||||
executeContinuously(project, action.substring(ContinuousExecutePrefix.length).trim)
|
||||
case action => handleAction(project, action)
|
||||
}
|
||||
}
|
||||
private def showActions(project: Project): Unit =
|
||||
Console.println(project.taskAndMethodList)
|
||||
|
||||
// returns true if it succeeded (needed by noninteractive handleCommand)
|
||||
private def handleAction(project: Project, action: String): Boolean =
|
||||
{
|
||||
def show(result: Option[String]): Boolean = showResult(result, project.log)
|
||||
val startTime = System.currentTimeMillis
|
||||
val result = withAction(project, action)( (name, params) => show(project.call(name, params)))( name => show(project.act(name)))
|
||||
printTime(project, startTime, "")
|
||||
result
|
||||
}
|
||||
private def showResult(result: Option[String], log: Logger): Boolean =
|
||||
{
|
||||
result match
|
||||
{
|
||||
case Some(errorMessage) => log.error(errorMessage); false
|
||||
case None => log.success("Successful."); true
|
||||
}
|
||||
}
|
||||
// true if the action exists
|
||||
private def checkAction(project: Project, actionString: String): Boolean =
|
||||
withAction(project, actionString)( (n,p) => true)( n => true)
|
||||
private def withAction(project: Project, actionString: String)(ifMethod: (String, Array[String]) => Boolean)(ifAction: String => Boolean): Boolean =
|
||||
{
|
||||
def didNotExist(taskType: String, name: String) =
|
||||
{
|
||||
project.log.error("No " + taskType + " named '" + name + "' exists.")
|
||||
project.log.info("Execute 'help' for a list of commands or 'actions' for a list of available project actions and methods.")
|
||||
false
|
||||
}
|
||||
impl.CommandParser.parse(actionString) match
|
||||
{
|
||||
case Left(errMsg) => project.log.error(errMsg); false
|
||||
case Right((name, parameters)) =>
|
||||
if(project.methods.contains(name))
|
||||
ifMethod(name, parameters.toArray)
|
||||
else if(!parameters.isEmpty)
|
||||
didNotExist("method", name)
|
||||
else if(project.deepTasks.contains(name))
|
||||
ifAction(name)
|
||||
else
|
||||
didNotExist("action", name)
|
||||
}
|
||||
}
|
||||
|
||||
/** Toggles whether stack traces are enabled.*/
|
||||
private def toggleTrace(project: Project)
|
||||
{
|
||||
val newValue = !project.log.traceEnabled
|
||||
project.topologicalSort.foreach(_.log.enableTrace(newValue))
|
||||
printTraceEnabled(project)
|
||||
}
|
||||
private def printTraceEnabled(project: Project)
|
||||
{
|
||||
Console.println("Stack traces are " + (if(project.log.traceEnabled) "enabled" else "disabled"))
|
||||
}
|
||||
/** Sets the logging level on the given project.*/
|
||||
private def setLevel(project: Project, level: Level.Value)
|
||||
{
|
||||
project.topologicalSort.foreach(_.log.setLevel(level))
|
||||
Console.println("Set log level to " + project.log.getLevel)
|
||||
}
|
||||
/** Prints the elapsed time to the given project's log using the given
|
||||
* initial time and the label 's'.*/
|
||||
private def printTime(project: Project, startTime: Long, s: String)
|
||||
{
|
||||
val endTime = System.currentTimeMillis()
|
||||
project.log.info("")
|
||||
val ss = if(s.isEmpty) "" else s + " "
|
||||
project.log.info("Total " + ss + "time: " + (endTime - startTime + 500) / 1000 + " s")
|
||||
}
|
||||
/** Provides a partial message describing why the given property is undefined. */
|
||||
private def undefinedMessage(property: Project#UserProperty[_]): String =
|
||||
{
|
||||
property.resolve match
|
||||
{
|
||||
case vu: UndefinedValue => " is not defined."
|
||||
case e: ResolutionException => " has invalid value: " + e.toString
|
||||
case _ => ""
|
||||
}
|
||||
}
|
||||
/** Prompts the user for the value of undefined properties. 'first' is true if this is the first time
|
||||
* that the current property has been prompted.*/
|
||||
private def fillUndefinedProperties(project: Project, properties: List[(String, Project#Property[_])], first: Boolean): Boolean =
|
||||
{
|
||||
properties match
|
||||
{
|
||||
case (name, variable) :: tail =>
|
||||
{
|
||||
val shouldAdvanceOrQuit =
|
||||
variable match
|
||||
{
|
||||
case property: Project#UserProperty[_] =>
|
||||
if(first)
|
||||
project.log.error(" Property '" + name + "' " + undefinedMessage(property))
|
||||
for(newValue <- SimpleReader.readLine(" Enter new value for " + name + " : ")) yield
|
||||
{
|
||||
try
|
||||
{
|
||||
property.setStringValue(newValue)
|
||||
true
|
||||
}
|
||||
catch
|
||||
{
|
||||
case e =>
|
||||
project.log.error("Invalid value: " + e.getMessage)
|
||||
false
|
||||
}
|
||||
}
|
||||
case _ => Some(true)
|
||||
}
|
||||
shouldAdvanceOrQuit match
|
||||
{
|
||||
case Some(shouldAdvance) => fillUndefinedProperties(project, if(shouldAdvance) tail else properties, shouldAdvance)
|
||||
case None => false
|
||||
}
|
||||
}
|
||||
case Nil => true
|
||||
}
|
||||
}
|
||||
/** Iterates over the undefined properties in the given projects, prompting the user for the value of each undefined
|
||||
* property.*/
|
||||
private def fillUndefinedProjectProperties(projects: List[Project]): Boolean =
|
||||
{
|
||||
projects match
|
||||
{
|
||||
case project :: remaining =>
|
||||
{
|
||||
val uninitialized = project.uninitializedProperties.toList
|
||||
if(uninitialized.isEmpty)
|
||||
fillUndefinedProjectProperties(remaining)
|
||||
else
|
||||
{
|
||||
project.log.error("Project in " + project.info.projectDirectory.getAbsolutePath + " has undefined properties.")
|
||||
val result = fillUndefinedProperties(project, uninitialized, true) && fillUndefinedProjectProperties(remaining)
|
||||
project.saveEnvironment()
|
||||
result
|
||||
}
|
||||
}
|
||||
case Nil => true
|
||||
}
|
||||
}
|
||||
/** Prints the value of the property with the given name in the given project. */
|
||||
private def getProperty(project: Project, propertyName: String)
|
||||
{
|
||||
if(propertyName.isEmpty)
|
||||
project.log.error("No property name specified.")
|
||||
else
|
||||
{
|
||||
project.getPropertyNamed(propertyName) match
|
||||
{
|
||||
case Some(property) =>
|
||||
{
|
||||
property.resolve match
|
||||
{
|
||||
case u: UndefinedValue => project.log.error("Value of property '" + propertyName + "' is undefined.")
|
||||
case ResolutionException(m, e) => project.log.error(m)
|
||||
case DefinedValue(value, isInherited, isDefault) => Console.println(value.toString)
|
||||
}
|
||||
}
|
||||
case None =>
|
||||
{
|
||||
val value = System.getProperty(propertyName)
|
||||
if(value == null)
|
||||
project.log.error("No property named '" + propertyName + "' is defined.")
|
||||
else
|
||||
Console.println(value)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Separates the space separated property name/value pair and stores the value in the user-defined property
|
||||
* with the given name in the given project. If no such property exists, the value is stored in a system
|
||||
* property. */
|
||||
private def setProperty(project: Project, propertyNameAndValue: String)
|
||||
{
|
||||
val m = """(\S+)(\s+\S.*)?""".r.pattern.matcher(propertyNameAndValue)
|
||||
if(m.matches())
|
||||
{
|
||||
val name = m.group(1)
|
||||
val newValue =
|
||||
{
|
||||
val v = m.group(2)
|
||||
if(v == null) "" else v.trim
|
||||
}
|
||||
project.getPropertyNamed(name) match
|
||||
{
|
||||
case Some(property) =>
|
||||
{
|
||||
val succeeded =
|
||||
try
|
||||
{
|
||||
property.setStringValue(newValue)
|
||||
val isScalaVersion = property == project.scalaVersion
|
||||
val isSbtVersion = property == project.sbtVersion
|
||||
if(isScalaVersion || isSbtVersion)
|
||||
{
|
||||
val changed = if(isSbtVersion) "sbt " else "Scala "
|
||||
Console.println(" Build will use " + changed + newValue + " after running 'reboot' command or restarting sbt.")
|
||||
}
|
||||
else
|
||||
Console.println(" Set property '" + name + "' = '" + newValue + "'")
|
||||
}
|
||||
catch { case e => project.log.error("Error setting property '" + name + "' in " + project.environmentLabel + ": " + e.toString) }
|
||||
project.saveEnvironment()
|
||||
}
|
||||
case None =>
|
||||
{
|
||||
System.setProperty(name, newValue)
|
||||
project.log.info(" Set system property '" + name + "' = '" + newValue + "'")
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
setArgumentError(project.log)
|
||||
}
|
||||
|
||||
private def compileContinuously(project: Project) = executeContinuously(project, "test-compile")
|
||||
private def executeContinuously(project: Project, action: String)
|
||||
{
|
||||
if(checkAction(project, action))
|
||||
{
|
||||
SourceModificationWatch.watchUntil(project, ContinuousCompilePollDelaySeconds)(System.in.available() > 0)
|
||||
{
|
||||
handleAction(project, action)
|
||||
Console.println("Waiting for source changes... (press any key to interrupt)")
|
||||
}
|
||||
while (System.in.available() > 0) System.in.read()
|
||||
}
|
||||
}
|
||||
|
||||
private def isTerminateAction(s: String) = TerminateActions.elements.contains(s.toLowerCase)
|
||||
private def setArgumentError(log: Logger) { log.error("Invalid arguments for 'set': expected property name and new value.") }
|
||||
private def getArgumentError(log: Logger) { log.error("Invalid arguments for 'get': expected property name.") }
|
||||
private def setProjectError(log: Logger) { log.error("Invalid arguments for 'project': expected project name.") }
|
||||
}
|
||||
private class CrossBuild(val remainingScalaVersions: Set[String], val command: String, val startTime: Long)
|
||||
{
|
||||
def error(setScalaVersion: String => Unit) = clearScalaVersion(setScalaVersion)
|
||||
private def clearScalaVersion(setScalaVersion: String => Unit) =
|
||||
{
|
||||
CrossBuild.clear()
|
||||
setScalaVersion("")
|
||||
true
|
||||
}
|
||||
def versionComplete(setScalaVersion: String => Unit) =
|
||||
{
|
||||
val remaining = remainingScalaVersions - ScalaVersion.currentString
|
||||
if(remaining.isEmpty)
|
||||
clearScalaVersion(setScalaVersion)
|
||||
else
|
||||
{
|
||||
CrossBuild.setProperties(remaining, command, startTime.toString)
|
||||
setScalaVersion(remaining.toSeq.first)
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
private object CrossBuild
|
||||
{
|
||||
private val RemainingScalaVersionsKey = "sbt.remaining.scala.versions"
|
||||
private val CrossCommandKey = "sbt.cross.build.command"
|
||||
private val StartTimeKey = "sbt.cross.start.time"
|
||||
private def setProperties(remainingScalaVersions: Set[String], command: String, startTime: String)
|
||||
{
|
||||
System.setProperty(RemainingScalaVersionsKey, remainingScalaVersions.mkString(" "))
|
||||
System.setProperty(CrossCommandKey, command)
|
||||
System.setProperty(StartTimeKey, startTime)
|
||||
}
|
||||
private def getProperty(key: String) =
|
||||
{
|
||||
val value = System.getProperty(key)
|
||||
if(value == null)
|
||||
""
|
||||
else
|
||||
value.trim
|
||||
}
|
||||
private def clear() { setProperties(Set.empty, "", "") }
|
||||
def load() =
|
||||
{
|
||||
val command = getProperty(CrossCommandKey)
|
||||
val remaining = getProperty(RemainingScalaVersionsKey)
|
||||
val startTime = getProperty(StartTimeKey)
|
||||
if(command.isEmpty || remaining.isEmpty || startTime.isEmpty)
|
||||
None
|
||||
else
|
||||
Some(new CrossBuild(Set(remaining.split(" ") : _*), command, startTime.toLong))
|
||||
}
|
||||
def apply(remainingScalaVersions: Set[String], command: String, startTime: Long) =
|
||||
{
|
||||
setProperties(remainingScalaVersions, command, startTime.toString)
|
||||
new CrossBuild(remainingScalaVersions, command, startTime)
|
||||
}
|
||||
import Main.CrossBuildPrefix
|
||||
def unapply(s: String): Option[String] =
|
||||
{
|
||||
val trimmed = s.trim
|
||||
if(trimmed.startsWith(CrossBuildPrefix))
|
||||
Some(trimmed.substring(CrossBuildPrefix.length).trim)
|
||||
else
|
||||
None
|
||||
}
|
||||
def unapply(s: Array[String]): Option[String] =
|
||||
s match
|
||||
{
|
||||
case Array(CrossBuild(crossBuildAction)) => Some(crossBuildAction)
|
||||
case _ => None
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,743 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import java.net.URL
|
||||
import java.util.Collections
|
||||
import scala.collection.mutable.HashSet
|
||||
|
||||
import Artifact.{defaultExtension, defaultType}
|
||||
|
||||
import org.apache.ivy.{core, plugins, util, Ivy}
|
||||
import core.LogOptions
|
||||
import core.cache.DefaultRepositoryCacheManager
|
||||
import core.deliver.DeliverOptions
|
||||
import core.module.descriptor.{DefaultArtifact, DefaultDependencyArtifactDescriptor, MDArtifact}
|
||||
import core.module.descriptor.{DefaultDependencyDescriptor, DefaultModuleDescriptor, DependencyDescriptor, ModuleDescriptor}
|
||||
import core.module.descriptor.{DefaultExcludeRule, ExcludeRule}
|
||||
import core.module.id.{ArtifactId,ModuleId, ModuleRevisionId}
|
||||
import core.publish.PublishOptions
|
||||
import core.resolve.ResolveOptions
|
||||
import core.retrieve.RetrieveOptions
|
||||
import core.settings.IvySettings
|
||||
import plugins.matcher.{ExactPatternMatcher, PatternMatcher}
|
||||
import plugins.parser.ModuleDescriptorParser
|
||||
import plugins.parser.m2.{PomModuleDescriptorParser,PomModuleDescriptorWriter}
|
||||
import plugins.parser.xml.XmlModuleDescriptorParser
|
||||
import plugins.repository.{BasicResource, Resource}
|
||||
import plugins.repository.url.URLResource
|
||||
import plugins.resolver.{ChainResolver, DependencyResolver, IBiblioResolver}
|
||||
import plugins.resolver.{AbstractPatternsBasedResolver, AbstractSshBasedResolver, FileSystemResolver, SFTPResolver, SshResolver, URLResolver}
|
||||
import util.{Message, MessageLogger}
|
||||
|
||||
final class IvyScala(val scalaVersion: String, val configurations: Iterable[Configuration], val checkExplicit: Boolean, val filterImplicit: Boolean) extends NotNull
|
||||
final class IvyPaths(val projectDirectory: Path, val managedLibDirectory: Path, val cacheDirectory: Option[Path]) extends NotNull
|
||||
final class IvyFlags(val validate: Boolean, val addScalaTools: Boolean, val errorIfNoConfiguration: Boolean) extends NotNull
|
||||
final class IvyConfiguration(val paths: IvyPaths, val manager: Manager, val flags: IvyFlags, val ivyScala: Option[IvyScala], val log: Logger) extends NotNull
|
||||
final class UpdateConfiguration(val outputPattern: String, val synchronize: Boolean, val quiet: Boolean) extends NotNull
|
||||
object ManageDependencies
|
||||
{
|
||||
val DefaultIvyConfigFilename = "ivysettings.xml"
|
||||
val DefaultIvyFilename = "ivy.xml"
|
||||
val DefaultMavenFilename = "pom.xml"
|
||||
val ScalaOrganization = "org.scala-lang"
|
||||
val ScalaLibraryID = "scala-library"
|
||||
val ScalaCompilerID = "scala-compiler"
|
||||
|
||||
private def defaultIvyFile(project: Path) = project / DefaultIvyFilename
|
||||
private def defaultIvyConfiguration(project: Path) = project / DefaultIvyConfigFilename
|
||||
private def defaultPOM(project: Path) = project / DefaultMavenFilename
|
||||
|
||||
/** Configures Ivy using the provided configuration 'config' and calls 'doWithIvy'. This method takes care of setting up and cleaning up Ivy.*/
|
||||
private def withIvy(config: IvyConfiguration)(doWithIvy: (Ivy, ModuleDescriptor, String) => Option[String]) =
|
||||
withIvyValue(config)( (ivy, module, default) => doWithIvy(ivy, module, default).toLeft(()) ).left.toOption
|
||||
/** Configures Ivy using the provided configuration 'config' and calls 'doWithIvy'. This method takes care of setting up and cleaning up Ivy.*/
|
||||
private def withIvyValue[T](config: IvyConfiguration)(doWithIvy: (Ivy, ModuleDescriptor, String) => Either[String, T]) =
|
||||
{
|
||||
import config._
|
||||
val logger = new IvyLogger(log)
|
||||
Message.setDefaultLogger(logger)
|
||||
val ivy = Ivy.newInstance()
|
||||
ivy.getLoggerEngine.pushLogger(logger)
|
||||
|
||||
/** Parses the given Maven pom 'pomFile'.*/
|
||||
def readPom(pomFile: File) =
|
||||
Control.trap("Could not read pom: ", log)
|
||||
{ Right((PomModuleDescriptorParser.getInstance.parseDescriptor(ivy.getSettings, toURL(pomFile), flags.validate)), "compile") }
|
||||
/** Parses the given Ivy file 'ivyFile'.*/
|
||||
def readIvyFile(ivyFile: File) =
|
||||
Control.trap("Could not read Ivy file: ", log)
|
||||
{
|
||||
val url = toURL(ivyFile)
|
||||
val parser = new CustomXmlParser.CustomParser(ivy.getSettings)
|
||||
parser.setValidate(flags.validate)
|
||||
parser.setSource(url)
|
||||
parser.parse()
|
||||
Right((parser.getModuleDescriptor(), parser.getDefaultConf))
|
||||
}
|
||||
/** Parses the given in-memory Ivy file 'xml', using the existing 'moduleID' and specifying the given 'defaultConfiguration'. */
|
||||
def parseXMLDependencies(xml: scala.xml.NodeSeq, moduleID: DefaultModuleDescriptor, defaultConfiguration: String) =
|
||||
parseDependencies(xml.toString, moduleID, defaultConfiguration)
|
||||
/** Parses the given in-memory Ivy file 'xml', using the existing 'moduleID' and specifying the given 'defaultConfiguration'. */
|
||||
def parseDependencies(xml: String, moduleID: DefaultModuleDescriptor, defaultConfiguration: String): Either[String, CustomXmlParser.CustomParser] =
|
||||
Control.trap("Could not read dependencies: ", log)
|
||||
{
|
||||
val parser = new CustomXmlParser.CustomParser(ivy.getSettings)
|
||||
parser.setMd(moduleID)
|
||||
parser.setDefaultConf(defaultConfiguration)
|
||||
parser.setValidate(flags.validate)
|
||||
val resource = new ByteResource(xml.getBytes)
|
||||
parser.setInput(resource.openStream)
|
||||
parser.setResource(resource)
|
||||
parser.parse()
|
||||
Right(parser)
|
||||
}
|
||||
/** Configures Ivy using the specified Ivy configuration file. This method is used when the manager is explicitly requested to be MavenManager or
|
||||
* IvyManager. If a file is not specified, Ivy is configured with defaults and scala-tools releases is added as a repository.*/
|
||||
def configure(configFile: Option[Path])
|
||||
{
|
||||
configFile match
|
||||
{
|
||||
case Some(path) => ivy.configure(path.asFile)
|
||||
case None =>
|
||||
configureDefaults()
|
||||
scalaTools()
|
||||
}
|
||||
}
|
||||
/** Adds the scala-tools.org releases maven repository to the list of resolvers if configured to do so in IvyFlags.*/
|
||||
def scalaTools()
|
||||
{
|
||||
if(flags.addScalaTools)
|
||||
{
|
||||
log.debug("Added Scala Tools Releases repository.")
|
||||
addResolvers(ivy.getSettings, ScalaToolsReleases :: Nil, log)
|
||||
}
|
||||
}
|
||||
/** Configures Ivy using defaults. This is done when no ivy-settings.xml exists. */
|
||||
def configureDefaults()
|
||||
{
|
||||
ivy.configureDefault
|
||||
val settings = ivy.getSettings
|
||||
for(dir <- paths.cacheDirectory) settings.setDefaultCache(dir.asFile)
|
||||
settings.setBaseDir(paths.projectDirectory.asFile)
|
||||
configureCache(settings)
|
||||
}
|
||||
/** Called to configure Ivy when the configured dependency manager is SbtManager and inline configuration is specified or if the manager
|
||||
* is AutodetectManager. It will configure Ivy with an 'ivy-settings.xml' file if there is one, or configure the defaults and add scala-tools as
|
||||
* a repository otherwise.*/
|
||||
def autodetectConfiguration()
|
||||
{
|
||||
log.debug("Autodetecting configuration.")
|
||||
val defaultIvyConfigFile = defaultIvyConfiguration(paths.projectDirectory).asFile
|
||||
if(defaultIvyConfigFile.canRead)
|
||||
ivy.configure(defaultIvyConfigFile)
|
||||
else
|
||||
{
|
||||
configureDefaults()
|
||||
scalaTools()
|
||||
}
|
||||
}
|
||||
/** Called to determine dependencies when the dependency manager is SbtManager and no inline dependencies (Scala or XML) are defined
|
||||
* or if the manager is AutodetectManager. It will try to read from pom.xml first and then ivy.xml if pom.xml is not found. If neither is found,
|
||||
* Ivy is configured with defaults unless IvyFlags.errorIfNoConfiguration is true, in which case an error is generated.*/
|
||||
def autodetectDependencies(module: ModuleRevisionId) =
|
||||
{
|
||||
log.debug("Autodetecting dependencies.")
|
||||
val defaultPOMFile = defaultPOM(paths.projectDirectory).asFile
|
||||
if(defaultPOMFile.canRead)
|
||||
readPom(defaultPOMFile)
|
||||
else
|
||||
{
|
||||
val defaultIvy = defaultIvyFile(paths.projectDirectory).asFile
|
||||
if(defaultIvy.canRead)
|
||||
readIvyFile(defaultIvy)
|
||||
else if(flags.errorIfNoConfiguration)
|
||||
Left("No readable dependency configuration found. Need " + DefaultIvyFilename + " or " + DefaultMavenFilename)
|
||||
else
|
||||
{
|
||||
val defaultConf = ModuleDescriptor.DEFAULT_CONFIGURATION
|
||||
log.warn("No readable dependency configuration found, using defaults.")
|
||||
val moduleID = DefaultModuleDescriptor.newDefaultInstance(module)
|
||||
addMainArtifact(moduleID)
|
||||
addDefaultArtifact(defaultConf, moduleID)
|
||||
Right((moduleID, defaultConf))
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Creates an Ivy module descriptor according the manager configured. The default configuration for dependencies
|
||||
* is also returned.*/
|
||||
def moduleDescriptor: Either[String, (ModuleDescriptor, String)] =
|
||||
config.manager match
|
||||
{
|
||||
case mm: MavenManager =>
|
||||
{
|
||||
log.debug("Maven configuration explicitly requested.")
|
||||
configure(mm.configuration)
|
||||
readPom(mm.pom.asFile)
|
||||
}
|
||||
case im: IvyManager =>
|
||||
{
|
||||
log.debug("Ivy configuration explicitly requested.")
|
||||
configure(im.configuration)
|
||||
readIvyFile(im.dependencies.asFile)
|
||||
}
|
||||
case adm: AutoDetectManager =>
|
||||
{
|
||||
log.debug("No dependency manager explicitly specified.")
|
||||
autodetectConfiguration()
|
||||
autodetectDependencies(toID(adm.module))
|
||||
}
|
||||
case sm: SbtManager =>
|
||||
{
|
||||
import sm._
|
||||
if(resolvers.isEmpty && autodetectUnspecified)
|
||||
autodetectConfiguration()
|
||||
else
|
||||
{
|
||||
log.debug("Using inline repositories.")
|
||||
configureDefaults()
|
||||
val extra = if(flags.addScalaTools) ScalaToolsReleases :: resolvers.toList else resolvers
|
||||
addResolvers(ivy.getSettings, extra, log)
|
||||
}
|
||||
if(autodetect)
|
||||
autodetectDependencies(toID(module))
|
||||
else
|
||||
{
|
||||
val moduleID =
|
||||
{
|
||||
val mod = new DefaultModuleDescriptor(toID(module), "release", null, false)
|
||||
mod.setLastModified(System.currentTimeMillis)
|
||||
configurations.foreach(config => mod.addConfiguration(toIvyConfiguration(config)))
|
||||
mod
|
||||
}
|
||||
val defaultConf = defaultConfiguration getOrElse Configurations.config(ModuleDescriptor.DEFAULT_CONFIGURATION)
|
||||
log.debug("Using inline dependencies specified in Scala" + (if(dependenciesXML.isEmpty) "." else " and XML."))
|
||||
for(parser <- parseXMLDependencies(wrapped(module, dependenciesXML), moduleID, defaultConf.name).right) yield
|
||||
{
|
||||
addArtifacts(moduleID, artifacts)
|
||||
addDependencies(moduleID, dependencies, parser)
|
||||
addMainArtifact(moduleID)
|
||||
(moduleID, parser.getDefaultConf)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Creates a full ivy file for 'module' using the 'dependencies' XML as the part after the <info>...</info> section. */
|
||||
def wrapped(module: ModuleID, dependencies: scala.xml.NodeSeq) =
|
||||
{
|
||||
import module._
|
||||
<ivy-module version="2.0">
|
||||
<info organisation={organization} module={name} revision={revision}/>
|
||||
{dependencies}
|
||||
</ivy-module>
|
||||
}
|
||||
/** Performs checks/adds filters on Scala dependencies (if enabled in IvyScala). */
|
||||
def checkModule(moduleAndConf: (ModuleDescriptor, String)): Either[String, (ModuleDescriptor, String)] =
|
||||
ivyScala match
|
||||
{
|
||||
case Some(check) =>
|
||||
val (module, conf) = moduleAndConf
|
||||
val explicitCheck =
|
||||
if(check.checkExplicit)
|
||||
checkDependencies(module, check.scalaVersion, check.configurations)
|
||||
else
|
||||
None
|
||||
explicitCheck match
|
||||
{
|
||||
case None =>
|
||||
if(check.filterImplicit)
|
||||
{
|
||||
val asDefault = toDefaultModuleDescriptor(module)
|
||||
excludeScalaJars(asDefault, check.configurations)
|
||||
Right( (asDefault, conf) )
|
||||
}
|
||||
else
|
||||
Right(moduleAndConf)
|
||||
case Some(err) => Left(err)
|
||||
}
|
||||
case None => Right(moduleAndConf)
|
||||
}
|
||||
|
||||
this.synchronized // Ivy is not thread-safe. In particular, it uses a static DocumentBuilder, which is not thread-safe
|
||||
{
|
||||
ivy.pushContext()
|
||||
try
|
||||
{
|
||||
moduleDescriptor.right.flatMap(checkModule).right.flatMap { mdAndConf =>
|
||||
doWithIvy(ivy, mdAndConf._1, mdAndConf._2)
|
||||
}
|
||||
}
|
||||
finally { ivy.popContext() }
|
||||
}
|
||||
}
|
||||
/** Checks the immediate dependencies of module for dependencies on scala jars and verifies that the version on the
|
||||
* dependencies matches scalaVersion. */
|
||||
private def checkDependencies(module: ModuleDescriptor, scalaVersion: String, configurations: Iterable[Configuration]): Option[String] =
|
||||
{
|
||||
val configSet = configurationSet(configurations)
|
||||
Control.lazyFold(module.getDependencies.toList)
|
||||
{ dep =>
|
||||
val id = dep.getDependencyRevisionId
|
||||
if(id.getOrganisation == ScalaOrganization && id.getRevision != scalaVersion && dep.getModuleConfigurations.exists(configSet.contains))
|
||||
Some("Different Scala version specified in dependency ("+ id.getRevision + ") than in project (" + scalaVersion + ").")
|
||||
else
|
||||
None
|
||||
}
|
||||
}
|
||||
private def configurationSet(configurations: Iterable[Configuration]) =
|
||||
HashSet(configurations.map(_.toString).toSeq : _*)
|
||||
/** Adds exclusions for the scala library and compiler jars so that they are not downloaded. This is
|
||||
* done because normally these jars are already on the classpath and cannot/should not be overridden. The version
|
||||
* of Scala to use is done by setting scala.version in the project definition. */
|
||||
private def excludeScalaJars(module: DefaultModuleDescriptor, configurations: Iterable[Configuration])
|
||||
{
|
||||
val configurationNames =
|
||||
{
|
||||
val names = module.getConfigurationsNames
|
||||
if(configurations.isEmpty)
|
||||
names
|
||||
else
|
||||
{
|
||||
import scala.collection.mutable.HashSet
|
||||
val configSet = configurationSet(configurations)
|
||||
configSet.intersect(HashSet(names : _*))
|
||||
configSet.toArray
|
||||
}
|
||||
}
|
||||
def excludeScalaJar(name: String)
|
||||
{ module.addExcludeRule(excludeRule(ScalaOrganization, name, configurationNames)) }
|
||||
excludeScalaJar(ScalaLibraryID)
|
||||
excludeScalaJar(ScalaCompilerID)
|
||||
}
|
||||
private def configureCache(settings: IvySettings)
|
||||
{
|
||||
settings.getDefaultRepositoryCacheManager match
|
||||
{
|
||||
case manager: DefaultRepositoryCacheManager =>
|
||||
manager.setUseOrigin(true)
|
||||
manager.setChangingMatcher(PatternMatcher.REGEXP);
|
||||
manager.setChangingPattern(".*-SNAPSHOT");
|
||||
case _ => ()
|
||||
}
|
||||
}
|
||||
/** Creates an ExcludeRule that excludes artifacts with the given module organization and name for
|
||||
* the given configurations. */
|
||||
private def excludeRule(organization: String, name: String, configurationNames: Iterable[String]): ExcludeRule =
|
||||
{
|
||||
val artifact = new ArtifactId(ModuleId.newInstance(organization, name), "*", "*", "*")
|
||||
val rule = new DefaultExcludeRule(artifact, ExactPatternMatcher.INSTANCE, Collections.emptyMap[AnyRef,AnyRef])
|
||||
configurationNames.foreach(rule.addConfiguration)
|
||||
rule
|
||||
}
|
||||
/** Clears the Ivy cache, as configured by 'config'. */
|
||||
def cleanCache(config: IvyConfiguration) =
|
||||
{
|
||||
def doClean(ivy: Ivy, module: ModuleDescriptor, default: String) =
|
||||
Control.trapUnit("Could not clean cache: ", config.log)
|
||||
{ ivy.getSettings.getRepositoryCacheManagers.foreach(_.clean()); None }
|
||||
|
||||
withIvy(config)(doClean)
|
||||
}
|
||||
/** Creates a Maven pom from the given Ivy configuration*/
|
||||
def makePom(config: IvyConfiguration, extraDependencies: Iterable[ModuleID], configurations: Option[Iterable[Configuration]], output: File) =
|
||||
{
|
||||
def doMakePom(ivy: Ivy, md: ModuleDescriptor, default: String) =
|
||||
Control.trapUnit("Could not make pom: ", config.log)
|
||||
{
|
||||
val module = addLateDependencies(ivy, md, default, extraDependencies)
|
||||
val pomModule = keepConfigurations(module, configurations)
|
||||
PomModuleDescriptorWriter.write(pomModule, DefaultConfigurationMapping, output)
|
||||
config.log.info("Wrote " + output.getAbsolutePath)
|
||||
None
|
||||
}
|
||||
withIvy(config)(doMakePom)
|
||||
}
|
||||
private def addDefaultArtifact(defaultConf: String, moduleID: DefaultModuleDescriptor) =
|
||||
moduleID.addArtifact(defaultConf, new MDArtifact(moduleID, moduleID.getModuleRevisionId.getName, defaultType, defaultExtension))
|
||||
// todo: correct default configuration for extra dependencies
|
||||
private def addLateDependencies(ivy: Ivy, md: ModuleDescriptor, defaultConfiguration: String, extraDependencies: Iterable[ModuleID]) =
|
||||
{
|
||||
val module = toDefaultModuleDescriptor(md)
|
||||
val parser = new CustomXmlParser.CustomParser(ivy.getSettings)
|
||||
parser.setMd(module)
|
||||
val defaultConf = if(defaultConfiguration.contains("->")) defaultConfiguration else (defaultConfiguration + "->default")
|
||||
parser.setDefaultConf(defaultConf)
|
||||
addDependencies(module, extraDependencies, parser)
|
||||
module
|
||||
}
|
||||
private def getConfigurations(module: ModuleDescriptor, configurations: Option[Iterable[Configuration]]) =
|
||||
configurations match
|
||||
{
|
||||
case Some(confs) => confs.map(_.name).toList.toArray
|
||||
case None => module.getPublicConfigurationsNames
|
||||
}
|
||||
/** Retain dependencies only with the configurations given, or all public configurations of `module` if `configurations` is None.
|
||||
* This is currently only preserves the information required by makePom*/
|
||||
private def keepConfigurations(module: ModuleDescriptor, configurations: Option[Iterable[Configuration]]): ModuleDescriptor =
|
||||
{
|
||||
val keepConfigurations = getConfigurations(module, configurations)
|
||||
val keepSet = Set(keepConfigurations.toSeq : _*)
|
||||
def translate(dependency: DependencyDescriptor) =
|
||||
{
|
||||
val keep = dependency.getModuleConfigurations.filter(keepSet.contains)
|
||||
if(keep.isEmpty)
|
||||
None
|
||||
else // TODO: translate the dependency to contain only configurations to keep
|
||||
Some(dependency)
|
||||
}
|
||||
val newModule = new DefaultModuleDescriptor(module.getModuleRevisionId, "", null)
|
||||
newModule.setHomePage(module.getHomePage)
|
||||
for(dependency <- module.getDependencies; translated <- translate(dependency))
|
||||
newModule.addDependency(translated)
|
||||
newModule
|
||||
}
|
||||
private def addConfigurations(configurations: Iterable[String], to: { def setConfs(c: Array[String]): AnyRef }): Unit =
|
||||
to.setConfs(configurations.toList.toArray)
|
||||
|
||||
def deliver(ivyConfig: IvyConfiguration, updateConfig: UpdateConfiguration, status: String, deliverIvyPattern: String, extraDependencies: Iterable[ModuleID], configurations: Option[Iterable[Configuration]]) =
|
||||
{
|
||||
def doDeliver(ivy: Ivy, md: ModuleDescriptor, default: String) =
|
||||
Control.trapUnit("Could not deliver: ", ivyConfig.log)
|
||||
{
|
||||
val module = addLateDependencies(ivy, md, default, extraDependencies)
|
||||
resolve(ivy, updateConfig, module) orElse
|
||||
{
|
||||
val revID = module.getModuleRevisionId
|
||||
val options = DeliverOptions.newInstance(ivy.getSettings).setStatus(status)
|
||||
options.setConfs(getConfigurations(module, configurations))
|
||||
|
||||
ivy.deliver(revID, revID.getRevision, deliverIvyPattern, options)
|
||||
None
|
||||
}
|
||||
}
|
||||
withIvy(ivyConfig)(doDeliver)
|
||||
}
|
||||
// todo: map configurations, extra dependencies
|
||||
def publish(ivyConfig: IvyConfiguration, resolverName: String, srcArtifactPatterns: Iterable[String], deliveredIvyPattern: Option[String], configurations: Option[Iterable[Configuration]]) =
|
||||
{
|
||||
def doPublish(ivy: Ivy, md: ModuleDescriptor, default: String) =
|
||||
Control.trapUnit("Could not publish: ", ivyConfig.log)
|
||||
{
|
||||
val revID = md.getModuleRevisionId
|
||||
val patterns = new java.util.ArrayList[String]
|
||||
srcArtifactPatterns.foreach(pattern => patterns.add(pattern))
|
||||
val options = (new PublishOptions).setOverwrite(true)
|
||||
deliveredIvyPattern.foreach(options.setSrcIvyPattern)
|
||||
options.setConfs(getConfigurations(md, configurations))
|
||||
ivy.publish(revID, patterns, resolverName, options)
|
||||
None
|
||||
}
|
||||
withIvy(ivyConfig)(doPublish)
|
||||
}
|
||||
/** Resolves and retrieves dependencies. 'ivyConfig' is used to produce an Ivy file and configuration.
|
||||
* 'updateConfig' configures the actual resolution and retrieval process. */
|
||||
def update(ivyConfig: IvyConfiguration, updateConfig: UpdateConfiguration) =
|
||||
{
|
||||
def processModule(ivy: Ivy, module: ModuleDescriptor, default: String) =
|
||||
{
|
||||
import updateConfig._
|
||||
Control.trapUnit("Could not process dependencies: ", ivyConfig.log)
|
||||
{
|
||||
resolve(ivy, updateConfig, module) orElse
|
||||
{
|
||||
val retrieveOptions = new RetrieveOptions
|
||||
retrieveOptions.setSync(synchronize)
|
||||
val patternBase = ivyConfig.paths.managedLibDirectory.absolutePath
|
||||
val pattern =
|
||||
if(patternBase.endsWith(File.separator))
|
||||
patternBase + outputPattern
|
||||
else
|
||||
patternBase + File.separatorChar + outputPattern
|
||||
ivy.retrieve(module.getModuleRevisionId, pattern, retrieveOptions)
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
withIvy(ivyConfig)(processModule)
|
||||
}
|
||||
private def resolve(ivy: Ivy, updateConfig: UpdateConfiguration, module: ModuleDescriptor) =
|
||||
{
|
||||
import updateConfig._
|
||||
val resolveOptions = new ResolveOptions
|
||||
if(quiet)
|
||||
resolveOptions.setLog(LogOptions.LOG_DOWNLOAD_ONLY)
|
||||
val resolveReport = ivy.resolve(module, resolveOptions)
|
||||
if(resolveReport.hasError)
|
||||
Some(Set(resolveReport.getAllProblemMessages.toArray: _*).mkString(System.getProperty("line.separator")))
|
||||
else
|
||||
None
|
||||
}
|
||||
/** This method is used to add inline dependencies to the provided module. */
|
||||
private def addDependencies(moduleID: DefaultModuleDescriptor, dependencies: Iterable[ModuleID], parser: CustomXmlParser.CustomParser)
|
||||
{
|
||||
for(dependency <- dependencies)
|
||||
{
|
||||
val dependencyDescriptor = new DefaultDependencyDescriptor(moduleID, toID(dependency), false, dependency.isChanging, dependency.isTransitive)
|
||||
dependency.configurations match
|
||||
{
|
||||
case None => // The configuration for this dependency was not explicitly specified, so use the default
|
||||
parser.parseDepsConfs(parser.getDefaultConf, dependencyDescriptor)
|
||||
case Some(confs) => // The configuration mapping (looks like: test->default) was specified for this dependency
|
||||
parser.parseDepsConfs(confs, dependencyDescriptor)
|
||||
}
|
||||
for(artifact <- dependency.explicitArtifacts)
|
||||
{
|
||||
import artifact.{name, `type`, extension, url}
|
||||
val ivyArtifact = new DefaultDependencyArtifactDescriptor(dependencyDescriptor, name, `type`, extension, url.getOrElse(null), null)
|
||||
for(conf <- dependencyDescriptor.getModuleConfigurations)
|
||||
dependencyDescriptor.addDependencyArtifact(conf, ivyArtifact)
|
||||
}
|
||||
moduleID.addDependency(dependencyDescriptor)
|
||||
}
|
||||
}
|
||||
private def addArtifacts(moduleID: DefaultModuleDescriptor, artifacts: Iterable[Artifact])
|
||||
{
|
||||
val allConfigurations = moduleID.getPublicConfigurationsNames
|
||||
for(artifact <- artifacts)
|
||||
{
|
||||
val configurationStrings =
|
||||
{
|
||||
val artifactConfigurations = artifact.configurations
|
||||
if(artifactConfigurations.isEmpty)
|
||||
allConfigurations
|
||||
else
|
||||
artifactConfigurations.map(_.name)
|
||||
}
|
||||
val ivyArtifact = toIvyArtifact(moduleID, artifact, configurationStrings)
|
||||
configurationStrings.foreach(configuration => moduleID.addArtifact(configuration, ivyArtifact))
|
||||
}
|
||||
}
|
||||
private def toURL(file: File) = file.toURI.toURL
|
||||
/** Adds the ivy.xml main artifact. */
|
||||
private def addMainArtifact(moduleID: DefaultModuleDescriptor)
|
||||
{
|
||||
val artifact = DefaultArtifact.newIvyArtifact(moduleID.getResolvedModuleRevisionId, moduleID.getPublicationDate)
|
||||
moduleID.setModuleArtifact(artifact)
|
||||
moduleID.check()
|
||||
}
|
||||
/** Sets the resolvers for 'settings' to 'resolvers'. This is done by creating a new chain and making it the default. */
|
||||
private def addResolvers(settings: IvySettings, resolvers: Iterable[Resolver], log: Logger)
|
||||
{
|
||||
val newDefault = new ChainResolver
|
||||
newDefault.setName("redefined-public")
|
||||
resolvers.foreach(r => newDefault.add(ConvertResolver(r)))
|
||||
newDefault.add(settings.getDefaultResolver)
|
||||
settings.addResolver(newDefault)
|
||||
settings.setDefaultResolver(newDefault.getName)
|
||||
if(log.atLevel(Level.Debug))
|
||||
{
|
||||
log.debug("Using extra repositories:")
|
||||
resolvers.foreach(r => log.debug("\t" + r.toString))
|
||||
}
|
||||
}
|
||||
private def toIvyConfiguration(configuration: Configuration) =
|
||||
{
|
||||
import org.apache.ivy.core.module.descriptor.{Configuration => IvyConfig}
|
||||
import IvyConfig.Visibility._
|
||||
import configuration._
|
||||
new IvyConfig(name, if(isPublic) PUBLIC else PRIVATE, description, extendsConfigs.map(_.name).toArray, transitive, null)
|
||||
}
|
||||
/** Converts the given sbt module id into an Ivy ModuleRevisionId.*/
|
||||
private def toID(m: ModuleID) =
|
||||
{
|
||||
import m._
|
||||
ModuleRevisionId.newInstance(organization, name, revision)
|
||||
}
|
||||
private def toIvyArtifact(moduleID: ModuleDescriptor, a: Artifact, configurations: Iterable[String]): MDArtifact =
|
||||
{
|
||||
val artifact = new MDArtifact(moduleID, a.name, a.`type`, a.extension)
|
||||
configurations.foreach(artifact.addConfiguration)
|
||||
artifact
|
||||
}
|
||||
/** An implementation of Ivy's Resource class that provides the Ivy file from a byte array. This is used to support
|
||||
* inline Ivy file XML.*/
|
||||
private class ByteResource(bytes: Array[Byte]) extends
|
||||
BasicResource("Inline XML dependencies", true, bytes.length, System.currentTimeMillis, true)
|
||||
{
|
||||
override def openStream = new java.io.ByteArrayInputStream(bytes)
|
||||
}
|
||||
/** Subclasses the default Ivy file parser in order to provide access to protected methods.*/
|
||||
private object CustomXmlParser extends XmlModuleDescriptorParser with NotNull
|
||||
{
|
||||
import XmlModuleDescriptorParser.Parser
|
||||
class CustomParser(settings: IvySettings) extends Parser(CustomXmlParser, settings) with NotNull
|
||||
{
|
||||
def setSource(url: URL) =
|
||||
{
|
||||
super.setResource(new URLResource(url))
|
||||
super.setInput(url)
|
||||
}
|
||||
/** Overridden because the super implementation overwrites the module descriptor.*/
|
||||
override def setResource(res: Resource) {}
|
||||
override def setMd(md: DefaultModuleDescriptor) = super.setMd(md)
|
||||
override def parseDepsConfs(confs: String, dd: DefaultDependencyDescriptor) = super.parseDepsConfs(confs, dd)
|
||||
override def getDefaultConf = super.getDefaultConf
|
||||
override def setDefaultConf(conf: String) = super.setDefaultConf(conf)
|
||||
}
|
||||
}
|
||||
/** This code converts the given ModuleDescriptor to a DefaultModuleDescriptor by casting or generating an error.
|
||||
* Ivy always produces a DefaultModuleDescriptor, so this should be reasonable. */
|
||||
private def toDefaultModuleDescriptor(md: ModuleDescriptor) =
|
||||
md match
|
||||
{
|
||||
case dmd: DefaultModuleDescriptor => dmd
|
||||
case _ => error("Unknown ModuleDescriptor type.")
|
||||
}
|
||||
}
|
||||
|
||||
private object ConvertResolver
|
||||
{
|
||||
/** Converts the given sbt resolver into an Ivy resolver..*/
|
||||
def apply(r: Resolver) =
|
||||
{
|
||||
r match
|
||||
{
|
||||
case repo: MavenRepository =>
|
||||
{
|
||||
val resolver = new IBiblioResolver
|
||||
initializeMavenStyle(resolver, repo.name, repo.root)
|
||||
resolver
|
||||
}
|
||||
case JavaNet1Repository =>
|
||||
{
|
||||
// Thanks to Matthias Pfau for posting how to use the Maven 1 repository on java.net with Ivy:
|
||||
// http://www.nabble.com/Using-gradle-Ivy-with-special-maven-repositories-td23775489.html
|
||||
val resolver = new IBiblioResolver { override def convertM2IdForResourceSearch(mrid: ModuleRevisionId) = mrid }
|
||||
initializeMavenStyle(resolver, JavaNet1Repository.name, "http://download.java.net/maven/1/")
|
||||
resolver.setPattern("[organisation]/[ext]s/[module]-[revision](-[classifier]).[ext]")
|
||||
resolver
|
||||
}
|
||||
case repo: SshRepository =>
|
||||
{
|
||||
val resolver = new SshResolver
|
||||
initializeSSHResolver(resolver, repo)
|
||||
repo.publishPermissions.foreach(perm => resolver.setPublishPermissions(perm))
|
||||
resolver
|
||||
}
|
||||
case repo: SftpRepository =>
|
||||
{
|
||||
val resolver = new SFTPResolver
|
||||
initializeSSHResolver(resolver, repo)
|
||||
resolver
|
||||
}
|
||||
case repo: FileRepository =>
|
||||
{
|
||||
val resolver = new FileSystemResolver
|
||||
resolver.setName(repo.name)
|
||||
initializePatterns(resolver, repo.patterns)
|
||||
import repo.configuration.{isLocal, isTransactional}
|
||||
resolver.setLocal(isLocal)
|
||||
isTransactional.foreach(value => resolver.setTransactional(value.toString))
|
||||
resolver
|
||||
}
|
||||
case repo: URLRepository =>
|
||||
{
|
||||
val resolver = new URLResolver
|
||||
resolver.setName(repo.name)
|
||||
initializePatterns(resolver, repo.patterns)
|
||||
resolver
|
||||
}
|
||||
}
|
||||
}
|
||||
private def initializeMavenStyle(resolver: IBiblioResolver, name: String, root: String)
|
||||
{
|
||||
resolver.setName(name)
|
||||
resolver.setM2compatible(true)
|
||||
resolver.setRoot(root)
|
||||
}
|
||||
private def initializeSSHResolver(resolver: AbstractSshBasedResolver, repo: SshBasedRepository)
|
||||
{
|
||||
resolver.setName(repo.name)
|
||||
resolver.setPassfile(null)
|
||||
initializePatterns(resolver, repo.patterns)
|
||||
initializeConnection(resolver, repo.connection)
|
||||
}
|
||||
private def initializeConnection(resolver: AbstractSshBasedResolver, connection: RepositoryHelpers.SshConnection)
|
||||
{
|
||||
import resolver._
|
||||
import connection._
|
||||
hostname.foreach(setHost)
|
||||
port.foreach(setPort)
|
||||
authentication foreach
|
||||
{
|
||||
case RepositoryHelpers.PasswordAuthentication(user, password) =>
|
||||
setUser(user)
|
||||
setUserPassword(password)
|
||||
case RepositoryHelpers.KeyFileAuthentication(file, password) =>
|
||||
setKeyFile(file)
|
||||
setKeyFilePassword(password)
|
||||
}
|
||||
}
|
||||
private def initializePatterns(resolver: AbstractPatternsBasedResolver, patterns: RepositoryHelpers.Patterns)
|
||||
{
|
||||
resolver.setM2compatible(patterns.isMavenCompatible)
|
||||
patterns.ivyPatterns.foreach(resolver.addIvyPattern)
|
||||
patterns.artifactPatterns.foreach(resolver.addArtifactPattern)
|
||||
}
|
||||
}
|
||||
|
||||
private object DefaultConfigurationMapping extends PomModuleDescriptorWriter.ConfigurationScopeMapping(new java.util.HashMap)
|
||||
{
|
||||
override def getScope(confs: Array[String]) =
|
||||
{
|
||||
Configurations.defaultMavenConfigurations.find(conf => confs.contains(conf.name)) match
|
||||
{
|
||||
case Some(conf) => conf.name
|
||||
case None =>
|
||||
if(confs.isEmpty || confs(0) == Configurations.Default.name)
|
||||
null
|
||||
else
|
||||
confs(0)
|
||||
}
|
||||
}
|
||||
override def isOptional(confs: Array[String]) = confs.isEmpty || (confs.length == 1 && confs(0) == Configurations.Optional.name)
|
||||
}
|
||||
|
||||
/** Interface between Ivy logging and sbt logging. */
|
||||
private final class IvyLogger(log: Logger) extends MessageLogger
|
||||
{
|
||||
private var progressEnabled = false
|
||||
|
||||
def log(msg: String, level: Int)
|
||||
{
|
||||
import Message.{MSG_DEBUG, MSG_VERBOSE, MSG_INFO, MSG_WARN, MSG_ERR}
|
||||
level match
|
||||
{
|
||||
case MSG_DEBUG | MSG_VERBOSE => debug(msg)
|
||||
case MSG_INFO => info(msg)
|
||||
case MSG_WARN => warn(msg)
|
||||
case MSG_ERR => error(msg)
|
||||
}
|
||||
}
|
||||
def rawlog(msg: String, level: Int)
|
||||
{
|
||||
log(msg, level)
|
||||
}
|
||||
import Level.{Debug, Info, Warn, Error}
|
||||
def debug(msg: String) = logImpl(msg, Debug)
|
||||
def verbose(msg: String) = debug(msg)
|
||||
def deprecated(msg: String) = warn(msg)
|
||||
def info(msg: String) = logImpl(msg, Info)
|
||||
def rawinfo(msg: String) = info(msg)
|
||||
def warn(msg: String) = logImpl(msg, Warn)
|
||||
def error(msg: String) = logImpl(msg, Error)
|
||||
|
||||
private def logImpl(msg: String, level: Level.Value) = log.log(level, msg)
|
||||
|
||||
private def emptyList = java.util.Collections.emptyList[T forSome { type T}]
|
||||
def getProblems = emptyList
|
||||
def getWarns = emptyList
|
||||
def getErrors = emptyList
|
||||
|
||||
def clearProblems = ()
|
||||
def sumupProblems = ()
|
||||
def progress = ()
|
||||
def endProgress = ()
|
||||
|
||||
def endProgress(msg: String) = info(msg)
|
||||
def isShowProgress = false
|
||||
def setShowProgress(progress: Boolean) {}
|
||||
}
|
||||
|
|
@ -0,0 +1,376 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import java.net.{URI, URL}
|
||||
import scala.xml.NodeSeq
|
||||
import org.apache.ivy.plugins.resolver.IBiblioResolver
|
||||
import org.apache.ivy.util.url.CredentialsStore
|
||||
|
||||
sealed abstract class Manager extends NotNull
|
||||
/** This explicitly requests auto detection as a dependency manager. It will first check for a 'pom.xml' file and if that does not exist, an 'ivy.xml' file.
|
||||
* Ivy is configured using the detected file or uses defaults.*/
|
||||
final class AutoDetectManager(val module: ModuleID) extends Manager
|
||||
/** This explicitly requests that the Maven pom 'pom' be used to determine dependencies. An Ivy configuration file to use may be specified in
|
||||
* 'configuration', since Ivy currently cannot extract Maven repositories from a pom file. Otherwise, defaults are used.*/
|
||||
final class MavenManager(val configuration: Option[Path], val pom: Path) extends Manager
|
||||
/** This explicitly requests that the Ivy file 'dependencies' be used to determine dependencies. An Ivy configuration file to use may be specified in
|
||||
* 'configuration'. Otherwise, defaults are used.*/
|
||||
final class IvyManager(val configuration: Option[Path], val dependencies: Path) extends Manager
|
||||
/** This manager directly specifies the dependencies, resolvers, and configurations through sbt wrapper classes and through an in-memory
|
||||
* Ivy XML file. */
|
||||
sealed trait SbtManager extends Manager
|
||||
{
|
||||
def autodetect: Boolean
|
||||
def module: ModuleID
|
||||
def resolvers: Iterable[Resolver]
|
||||
def dependencies: Iterable[ModuleID]
|
||||
def autodetectUnspecified: Boolean
|
||||
def dependenciesXML: NodeSeq
|
||||
def configurations: Iterable[Configuration]
|
||||
def defaultConfiguration: Option[Configuration]
|
||||
def artifacts: Iterable[Artifact]
|
||||
}
|
||||
final class SimpleManager private[sbt] (val dependenciesXML: NodeSeq, val autodetectUnspecified: Boolean,
|
||||
val module: ModuleID, val resolvers: Iterable[Resolver], explicitConfigurations: Iterable[Configuration],
|
||||
val defaultConfiguration: Option[Configuration], val artifacts: Iterable[Artifact], val dependencies: ModuleID*) extends SbtManager
|
||||
{
|
||||
def autodetect = dependencies.isEmpty && dependenciesXML.isEmpty && artifacts.isEmpty && explicitConfigurations.isEmpty && autodetectUnspecified
|
||||
def configurations =
|
||||
if(explicitConfigurations.isEmpty && !autodetect)
|
||||
{
|
||||
defaultConfiguration match
|
||||
{
|
||||
case Some(Configurations.DefaultIvyConfiguration) => Configurations.Default :: Nil
|
||||
case Some(Configurations.DefaultMavenConfiguration) => Configurations.defaultMavenConfigurations
|
||||
case _ => Nil
|
||||
}
|
||||
}
|
||||
else
|
||||
explicitConfigurations
|
||||
}
|
||||
|
||||
final case class ModuleID(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, explicitArtifacts: Seq[Artifact]) extends NotNull
|
||||
{
|
||||
override def toString = organization + ":" + name + ":" + revision
|
||||
// () required for chaining
|
||||
def notTransitive() = intransitive()
|
||||
def intransitive() = ModuleID(organization, name, revision, configurations, isChanging, false, explicitArtifacts)
|
||||
def changing() = ModuleID(organization, name, revision, configurations, true, isTransitive, explicitArtifacts)
|
||||
def from(url: String) = artifacts(Artifact(name, new URL(url)))
|
||||
def artifacts(newArtifacts: Artifact*) = ModuleID(organization, name, revision, configurations, isChanging, isTransitive, newArtifacts ++ explicitArtifacts)
|
||||
}
|
||||
object ModuleID
|
||||
{
|
||||
def apply(organization: String, name: String, revision: String): ModuleID = ModuleID(organization, name, revision, None)
|
||||
def apply(organization: String, name: String, revision: String, configurations: Option[String]): ModuleID =
|
||||
ModuleID(organization, name, revision, configurations, false, true)
|
||||
def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean): ModuleID =
|
||||
ModuleID(organization, name, revision, configurations, isChanging, isTransitive, Nil)
|
||||
}
|
||||
sealed trait Resolver extends NotNull
|
||||
{
|
||||
def name: String
|
||||
}
|
||||
sealed case class MavenRepository(name: String, root: String) extends Resolver
|
||||
{
|
||||
override def toString = name + ": " + root
|
||||
}
|
||||
|
||||
object RepositoryHelpers
|
||||
{
|
||||
final case class Patterns(ivyPatterns: Seq[String], artifactPatterns: Seq[String], isMavenCompatible: Boolean) extends NotNull
|
||||
{
|
||||
private[sbt] def mavenStyle(): Patterns = Patterns(ivyPatterns, artifactPatterns, true)
|
||||
private[sbt] def withIvys(patterns: Seq[String]): Patterns = Patterns(patterns ++ ivyPatterns, artifactPatterns, isMavenCompatible)
|
||||
private[sbt] def withArtifacts(patterns: Seq[String]): Patterns = Patterns(ivyPatterns, patterns ++ artifactPatterns, isMavenCompatible)
|
||||
}
|
||||
final case class SshConnection(authentication: Option[SshAuthentication], hostname: Option[String], port: Option[Int]) extends NotNull
|
||||
{
|
||||
def copy(authentication: Option[SshAuthentication]) = SshConnection(authentication, hostname, port)
|
||||
}
|
||||
/** Configuration specific to an Ivy filesystem resolver. */
|
||||
final case class FileConfiguration(isLocal: Boolean, isTransactional: Option[Boolean]) extends NotNull
|
||||
{
|
||||
def transactional() = FileConfiguration(isLocal, Some(true))
|
||||
def nontransactional() = FileConfiguration(isLocal, Some(false))
|
||||
def nonlocal() = FileConfiguration(false, isTransactional)
|
||||
}
|
||||
sealed trait SshAuthentication extends NotNull
|
||||
final case class PasswordAuthentication(user: String, password: String) extends SshAuthentication
|
||||
final case class KeyFileAuthentication(keyfile: File, password: String) extends SshAuthentication
|
||||
}
|
||||
import RepositoryHelpers.{Patterns, SshConnection, FileConfiguration}
|
||||
import RepositoryHelpers.{KeyFileAuthentication, PasswordAuthentication, SshAuthentication}
|
||||
|
||||
/** sbt interface to an Ivy repository based on patterns, which is most Ivy repositories.*/
|
||||
sealed abstract class PatternsBasedRepository extends Resolver
|
||||
{
|
||||
type RepositoryType <: PatternsBasedRepository
|
||||
/** Should be implemented to create a new copy of this repository but with `patterns` as given.*/
|
||||
protected def copy(patterns: Patterns): RepositoryType
|
||||
|
||||
/** The object representing the configured patterns for this repository. */
|
||||
def patterns: Patterns
|
||||
|
||||
/** Enables maven 2 compatibility for this repository. */
|
||||
def mavenStyle() = copy(patterns.mavenStyle())
|
||||
/** Adds the given patterns for resolving/publishing Ivy files.*/
|
||||
def ivys(ivyPatterns: String*): RepositoryType = copy(patterns.withIvys(ivyPatterns))
|
||||
/** Adds the given patterns for resolving/publishing artifacts.*/
|
||||
def artifacts(artifactPatterns: String*): RepositoryType = copy(patterns.withArtifacts(artifactPatterns))
|
||||
}
|
||||
/** sbt interface for an Ivy filesystem repository. More convenient construction is done using Resolver.file. */
|
||||
final case class FileRepository(name: String, configuration: FileConfiguration, patterns: Patterns) extends PatternsBasedRepository
|
||||
{
|
||||
type RepositoryType = FileRepository
|
||||
protected def copy(patterns: Patterns): FileRepository = FileRepository(name, configuration, patterns)
|
||||
private def copy(configuration: FileConfiguration) = FileRepository(name, configuration, patterns)
|
||||
def transactional() = copy(configuration.transactional())
|
||||
def nonlocal() = copy(configuration.nonlocal())
|
||||
}
|
||||
final case class URLRepository(name: String, patterns: Patterns) extends PatternsBasedRepository
|
||||
{
|
||||
type RepositoryType = URLRepository
|
||||
protected def copy(patterns: Patterns): URLRepository = URLRepository(name, patterns)
|
||||
}
|
||||
/** sbt interface for an Ivy ssh-based repository (ssh and sftp). Requires the Jsch library.. */
|
||||
sealed abstract class SshBasedRepository extends PatternsBasedRepository
|
||||
{
|
||||
type RepositoryType <: SshBasedRepository
|
||||
protected def copy(connection: SshConnection): RepositoryType
|
||||
private def copy(authentication: SshAuthentication): RepositoryType = copy(connection.copy(Some(authentication)))
|
||||
|
||||
/** The object representing the configured ssh connection for this repository. */
|
||||
def connection: SshConnection
|
||||
|
||||
/** Configures this to use the specified user name and password when connecting to the remote repository. */
|
||||
def as(user: String, password: String): RepositoryType = copy(new PasswordAuthentication(user, password))
|
||||
/** Configures this to use the specified keyfile and password for the keyfile when connecting to the remote repository. */
|
||||
def as(keyfile: File, password: String): RepositoryType = copy(new KeyFileAuthentication(keyfile, password))
|
||||
}
|
||||
/** sbt interface for an Ivy repository over ssh. More convenient construction is done using Resolver.ssh. */
|
||||
final case class SshRepository(name: String, connection: SshConnection, patterns: Patterns, publishPermissions: Option[String]) extends SshBasedRepository
|
||||
{
|
||||
type RepositoryType = SshRepository
|
||||
protected def copy(patterns: Patterns): SshRepository = SshRepository(name, connection, patterns, publishPermissions)
|
||||
protected def copy(connection: SshConnection): SshRepository = SshRepository(name, connection, patterns, publishPermissions)
|
||||
/** Defines the permissions to set when publishing to this repository. */
|
||||
def withPermissions(publishPermissions: String): SshRepository = withPermissions(Some(publishPermissions))
|
||||
def withPermissions(publishPermissions: Option[String]): SshRepository = SshRepository(name, connection, patterns, publishPermissions)
|
||||
}
|
||||
/** sbt interface for an Ivy repository over sftp. More convenient construction is done using Resolver.sftp. */
|
||||
final case class SftpRepository(name: String, connection: SshConnection, patterns: Patterns) extends SshBasedRepository
|
||||
{
|
||||
type RepositoryType = SftpRepository
|
||||
protected def copy(patterns: Patterns): SftpRepository = SftpRepository(name, connection, patterns)
|
||||
protected def copy(connection: SshConnection): SftpRepository = SftpRepository(name, connection, patterns)
|
||||
}
|
||||
|
||||
import Resolver._
|
||||
object ScalaToolsReleases extends MavenRepository(ScalaToolsReleasesName, ScalaToolsReleasesRoot)
|
||||
object ScalaToolsSnapshots extends MavenRepository(ScalaToolsSnapshotsName, ScalaToolsSnapshotsRoot)
|
||||
object DefaultMavenRepository extends MavenRepository("Maven2 Repository", IBiblioResolver.DEFAULT_M2_ROOT)
|
||||
object JavaNet1Repository extends Resolver
|
||||
{
|
||||
def name = "java.net Maven1 Repository"
|
||||
}
|
||||
|
||||
object Resolver
|
||||
{
|
||||
val ScalaToolsReleasesName = "Scala-Tools Maven2 Repository"
|
||||
val ScalaToolsSnapshotsName = "Scala-Tools Maven2 Snapshots Repository"
|
||||
val ScalaToolsReleasesRoot = "http://scala-tools.org/repo-releases"
|
||||
val ScalaToolsSnapshotsRoot = "http://scala-tools.org/repo-snapshots"
|
||||
|
||||
/** A base class for defining factories for interfaces to Ivy repositories that require a hostname , port, and patterns. */
|
||||
sealed abstract class Define[RepositoryType <: SshBasedRepository] extends NotNull
|
||||
{
|
||||
/** Subclasses should implement this method to */
|
||||
protected def construct(name: String, connection: SshConnection, patterns: Patterns): RepositoryType
|
||||
/** Constructs this repository type with the given `name`. `basePatterns` are the initial patterns to use. A ManagedProject
|
||||
* has an implicit defining these initial patterns based on a setting for either Maven or Ivy style patterns.*/
|
||||
def apply(name: String)(implicit basePatterns: Patterns): RepositoryType =
|
||||
apply(name, None, None, None)
|
||||
/** Constructs this repository type with the given `name` and `hostname`. `basePatterns` are the initial patterns to use.
|
||||
* A ManagedProject has an implicit defining these initial patterns based on a setting for either Maven or Ivy style patterns.*/
|
||||
def apply(name: String, hostname: String)(implicit basePatterns: Patterns): RepositoryType =
|
||||
apply(name, Some(hostname), None, None)
|
||||
/** Constructs this repository type with the given `name`, `hostname`, and the `basePath` against which the initial
|
||||
* patterns will be resolved. `basePatterns` are the initial patterns to use.
|
||||
* A ManagedProject has an implicit defining these initial patterns based on a setting for either Maven or Ivy style patterns.*/
|
||||
def apply(name: String, hostname: String, basePath: String)(implicit basePatterns: Patterns): RepositoryType =
|
||||
apply(name, Some(hostname), None, Some(basePath))
|
||||
/** Constructs this repository type with the given `name`, `hostname`, and `port`. `basePatterns` are the initial patterns to use.
|
||||
* A ManagedProject has an implicit defining these initial patterns based on a setting for either Maven or Ivy style patterns.*/
|
||||
def apply(name: String, hostname: String, port: Int)(implicit basePatterns: Patterns): RepositoryType =
|
||||
apply(name, Some(hostname), Some(port), None)
|
||||
/** Constructs this repository type with the given `name`, `hostname`, `port`, and the `basePath` against which the initial
|
||||
* patterns will be resolved. `basePatterns` are the initial patterns to use.
|
||||
* A ManagedProject has an implicit defining these initial patterns based on a setting for either Maven or Ivy style patterns.*/
|
||||
def apply(name: String, hostname: String, port: Int, basePath: String)(implicit basePatterns: Patterns): RepositoryType =
|
||||
apply(name, Some(hostname), Some(port), Some(basePath))
|
||||
/** Constructs this repository type with the given `name`, `hostname`, `port`, and the `basePath` against which the initial
|
||||
* patterns will be resolved. `basePatterns` are the initial patterns to use. All but the `name` are optional (use None).
|
||||
* A ManagedProject has an implicit defining these initial patterns based on a setting for either Maven or Ivy style patterns.*/
|
||||
def apply(name: String, hostname: Option[String], port: Option[Int], basePath: Option[String])(implicit basePatterns: Patterns): RepositoryType =
|
||||
construct(name, SshConnection(None, hostname, port), resolvePatterns(basePath, basePatterns))
|
||||
}
|
||||
/** A factory to construct an interface to an Ivy SSH resolver.*/
|
||||
object ssh extends Define[SshRepository]
|
||||
{
|
||||
protected def construct(name: String, connection: SshConnection, patterns: Patterns) = SshRepository(name, connection, patterns, None)
|
||||
}
|
||||
/** A factory to construct an interface to an Ivy SFTP resolver.*/
|
||||
object sftp extends Define[SftpRepository]
|
||||
{
|
||||
protected def construct(name: String, connection: SshConnection, patterns: Patterns) = SftpRepository(name, connection, patterns)
|
||||
}
|
||||
/** A factory to construct an interface to an Ivy filesytem resolver. */
|
||||
object file
|
||||
{
|
||||
/** Constructs a file resolver with the given name. The patterns to use must be explicitly specified
|
||||
* using the `ivys` or `artifacts` methods on the constructed resolver object.*/
|
||||
def apply(name: String): FileRepository = FileRepository(name, defaultFileConfiguration, ivyStylePatterns)
|
||||
/** Constructs a file resolver with the given name and base directory. */
|
||||
def apply(name: String, baseDirectory: File)(implicit basePatterns: Patterns): FileRepository =
|
||||
baseRepository(baseDirectory.toURI)(FileRepository(name, defaultFileConfiguration, _))
|
||||
}
|
||||
object url
|
||||
{
|
||||
/** Constructs a URL resolver with the given name. The patterns to use must be explicitly specified
|
||||
* using the `ivys` or `artifacts` methods on the constructed resolver object.*/
|
||||
def apply(name: String): URLRepository = URLRepository(name, ivyStylePatterns)
|
||||
/** Constructs a file resolver with the given name and base directory. */
|
||||
def apply(name: String, baseURL: URL)(implicit basePatterns: Patterns): URLRepository =
|
||||
baseRepository(baseURL.toURI)(URLRepository(name, _))
|
||||
}
|
||||
private def baseRepository[T](baseURI: java.net.URI)(construct: Patterns => T)(implicit basePatterns: Patterns): T =
|
||||
construct(resolvePatterns(baseURI.normalize, basePatterns))
|
||||
|
||||
/** If `base` is None, `patterns` is returned unchanged.
|
||||
* Otherwise, the ivy file and artifact patterns in `patterns` are resolved against the given base. */
|
||||
private def resolvePatterns(base: Option[String], patterns: Patterns): Patterns =
|
||||
base match
|
||||
{
|
||||
case Some(path) => resolvePatterns(pathURI(path), patterns)
|
||||
case None => patterns
|
||||
}
|
||||
/** Resolves the ivy file and artifact patterns in `patterns` against the given base. */
|
||||
private def resolvePatterns(base: URI, basePatterns: Patterns): Patterns =
|
||||
{
|
||||
def resolve(pattern: String) = base.resolve(pathURI(pattern)).getPath
|
||||
def resolveAll(patterns: Seq[String]) = patterns.map(resolve)
|
||||
Patterns(resolveAll(basePatterns.ivyPatterns), resolveAll(basePatterns.artifactPatterns), basePatterns.isMavenCompatible)
|
||||
}
|
||||
/** Constructs a `URI` with the path component set to `path` and the other components set to null.*/
|
||||
private def pathURI(path: String) = new URI(null, null, path, null)
|
||||
|
||||
def defaultFileConfiguration = FileConfiguration(true, None)
|
||||
def mavenStylePatterns = Patterns(Nil, mavenStyleBasePattern :: Nil, true)
|
||||
def ivyStylePatterns = Patterns(Nil, Nil, false)
|
||||
|
||||
def defaultPatterns = mavenStylePatterns
|
||||
def mavenStyleBasePattern = "[organisation]/[module]/[revision]/[artifact]-[revision](-[classifier]).[ext]"
|
||||
}
|
||||
|
||||
object Configurations
|
||||
{
|
||||
def config(name: String) = new Configuration(name)
|
||||
def defaultMavenConfigurations = Compile :: Runtime :: Test :: Provided :: System :: Optional :: Sources :: Javadoc :: Nil
|
||||
|
||||
lazy val Default = config("default")
|
||||
lazy val Compile = config("compile")
|
||||
lazy val IntegrationTest = config("it") hide
|
||||
lazy val Provided = config("provided")
|
||||
lazy val Javadoc = config("javadoc")
|
||||
lazy val Runtime = config("runtime")
|
||||
lazy val Test = config("test") hide
|
||||
lazy val Sources = config("sources")
|
||||
lazy val System = config("system")
|
||||
lazy val Optional = config("optional")
|
||||
|
||||
lazy val CompilerPlugin = config("plugin") hide
|
||||
|
||||
private[sbt] val DefaultMavenConfiguration = defaultConfiguration(true)
|
||||
private[sbt] val DefaultIvyConfiguration = defaultConfiguration(false)
|
||||
private[sbt] def DefaultConfiguration(mavenStyle: Boolean) = if(mavenStyle) DefaultMavenConfiguration else DefaultIvyConfiguration
|
||||
private[sbt] def defaultConfiguration(mavenStyle: Boolean) =
|
||||
{
|
||||
val base = if(mavenStyle) Configurations.Compile else Configurations.Default
|
||||
config(base.name + "->default(compile)")
|
||||
}
|
||||
|
||||
private[sbt] def removeDuplicates(configs: Iterable[Configuration]) = Set(scala.collection.mutable.Map(configs.map(config => (config.name, config)).toSeq: _*).values.toList: _*)
|
||||
}
|
||||
/** Represents an Ivy configuration. */
|
||||
final case class Configuration(name: String, description: String, isPublic: Boolean, extendsConfigs: List[Configuration], transitive: Boolean) extends NotNull
|
||||
{
|
||||
require(name != null && !name.isEmpty)
|
||||
require(description != null)
|
||||
def this(name: String) = this(name, "", true, Nil, true)
|
||||
def describedAs(newDescription: String) = Configuration(name, newDescription, isPublic, extendsConfigs, transitive)
|
||||
def extend(configs: Configuration*) = Configuration(name, description, isPublic, configs.toList ::: extendsConfigs, transitive)
|
||||
def notTransitive = intransitive
|
||||
def intransitive = Configuration(name, description, isPublic, extendsConfigs, false)
|
||||
def hide = Configuration(name, description, false, extendsConfigs, transitive)
|
||||
override def toString = name
|
||||
}
|
||||
|
||||
final case class Artifact(name: String, `type`: String, extension: String, configurations: Iterable[Configuration], url: Option[URL]) extends NotNull
|
||||
object Artifact
|
||||
{
|
||||
def apply(name: String): Artifact = Artifact(name, defaultType, defaultExtension, Nil, None)
|
||||
def apply(name: String, `type`: String, extension: String): Artifact = Artifact(name, `type`, extension, Nil, None)
|
||||
def apply(name: String, url: URL): Artifact =Artifact(name, extract(url, defaultType), extract(url, defaultExtension), Nil, Some(url))
|
||||
val defaultExtension = "jar"
|
||||
val defaultType = "jar"
|
||||
private[this] def extract(url: URL, default: String) =
|
||||
{
|
||||
val s = url.toString
|
||||
val i = s.lastIndexOf('.')
|
||||
if(i >= 0)
|
||||
s.substring(i+1)
|
||||
else
|
||||
default
|
||||
}
|
||||
}
|
||||
|
||||
object Credentials
|
||||
{
|
||||
/** Add the provided credentials to Ivy's credentials cache.*/
|
||||
def add(realm: String, host: String, userName: String, passwd: String): Unit =
|
||||
CredentialsStore.INSTANCE.addCredentials(realm, host, userName, passwd)
|
||||
/** Load credentials from the given file into Ivy's credentials cache.*/
|
||||
def apply(file: String, log: Logger): Unit = apply(Path.fromFile(file), log)
|
||||
/** Load credentials from the given file into Ivy's credentials cache.*/
|
||||
def apply(file: File, log: Logger): Unit = apply(Path.fromFile(file), log)
|
||||
/** Load credentials from the given file into Ivy's credentials cache.*/
|
||||
def apply(path: Path, log: Logger)
|
||||
{
|
||||
val msg =
|
||||
if(path.exists)
|
||||
{
|
||||
val properties = new scala.collection.mutable.HashMap[String, String]
|
||||
def get(keys: List[String]) = keys.flatMap(properties.get).firstOption.toRight(keys.head + " not specified in credentials file: " + path)
|
||||
|
||||
impl.MapUtilities.read(properties, path, log) orElse
|
||||
{
|
||||
List.separate( List(RealmKeys, HostKeys, UserKeys, PasswordKeys).map(get) ) match
|
||||
{
|
||||
case (Nil, List(realm, host, user, pass)) => add(realm, host, user, pass); None
|
||||
case (errors, _) => Some(errors.mkString("\n"))
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
Some("Credentials file " + path + " does not exist")
|
||||
msg.foreach(x => log.warn(x))
|
||||
}
|
||||
private[this] val RealmKeys = List("realm")
|
||||
private[this] val HostKeys = List("host", "hostname")
|
||||
private[this] val UserKeys = List("user", "user.name", "username")
|
||||
private[this] val PasswordKeys = List("password", "pwd", "pass", "passwd")
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
object ModuleUtilities
|
||||
{
|
||||
def getObject(className: String, loader: ClassLoader) =
|
||||
{
|
||||
val obj = Class.forName(className + "$", true, loader)
|
||||
val singletonField = obj.getField("MODULE$")
|
||||
singletonField.get(null)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import java.util.regex.Pattern
|
||||
|
||||
trait FileFilter extends java.io.FileFilter with NotNull
|
||||
{
|
||||
def || (filter: FileFilter): FileFilter = new SimpleFileFilter( file => accept(file) || filter.accept(file) )
|
||||
def && (filter: FileFilter): FileFilter = new SimpleFileFilter( file => accept(file) && filter.accept(file) )
|
||||
def -- (filter: FileFilter): FileFilter = new SimpleFileFilter( file => accept(file) && !filter.accept(file) )
|
||||
def unary_- : FileFilter = new SimpleFileFilter( file => !accept(file) )
|
||||
}
|
||||
trait NameFilter extends FileFilter with NotNull
|
||||
{
|
||||
def accept(name: String): Boolean
|
||||
final def accept(file: File): Boolean = accept(file.getName)
|
||||
def | (filter: NameFilter): NameFilter = new SimpleFilter( name => accept(name) || filter.accept(name) )
|
||||
def & (filter: NameFilter): NameFilter = new SimpleFilter( name => accept(name) && filter.accept(name) )
|
||||
def - (filter: NameFilter): NameFilter = new SimpleFilter( name => accept(name) && !filter.accept(name) )
|
||||
override def unary_- : NameFilter = new SimpleFilter( name => !accept(name) )
|
||||
}
|
||||
object HiddenFileFilter extends FileFilter {
|
||||
def accept(file: File) = file.isHidden && file.getName != "."
|
||||
}
|
||||
object ExistsFileFilter extends FileFilter {
|
||||
def accept(file: File) = file.exists
|
||||
}
|
||||
object DirectoryFilter extends FileFilter {
|
||||
def accept(file: File) = file.isDirectory
|
||||
}
|
||||
class SimpleFileFilter(val acceptFunction: File => Boolean) extends FileFilter
|
||||
{
|
||||
def accept(file: File) = acceptFunction(file)
|
||||
}
|
||||
class ExactFilter(val matchName: String) extends NameFilter
|
||||
{
|
||||
def accept(name: String) = matchName == name
|
||||
}
|
||||
class SimpleFilter(val acceptFunction: String => Boolean) extends NameFilter
|
||||
{
|
||||
def accept(name: String) = acceptFunction(name)
|
||||
}
|
||||
class PatternFilter(val pattern: Pattern) extends NameFilter
|
||||
{
|
||||
def accept(name: String) = pattern.matcher(name).matches
|
||||
}
|
||||
object AllPassFilter extends NameFilter
|
||||
{
|
||||
def accept(name: String) = true
|
||||
}
|
||||
object NothingFilter extends NameFilter
|
||||
{
|
||||
def accept(name: String) = false
|
||||
}
|
||||
|
||||
object GlobFilter
|
||||
{
|
||||
def apply(expression: String): NameFilter =
|
||||
{
|
||||
require(!expression.exists(java.lang.Character.isISOControl), "Control characters not allowed in filter expression.")
|
||||
if(expression == "*")
|
||||
AllPassFilter
|
||||
else if(expression.indexOf('*') < 0) // includes case where expression is empty
|
||||
new ExactFilter(expression)
|
||||
else
|
||||
new PatternFilter(Pattern.compile(expression.split("\\*", -1).map(quote).mkString(".*")))
|
||||
}
|
||||
private def quote(s: String) = if(s.isEmpty) "" else Pattern.quote(s.replaceAll("\n", """\n"""))
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.{File, FileOutputStream}
|
||||
import java.util.jar.{JarEntry, JarFile, JarOutputStream, Pack200}
|
||||
import scala.collection.Map
|
||||
import FileUtilities._
|
||||
|
||||
object Pack
|
||||
{
|
||||
def pack(jarPath: Path, out: Path, log: Logger): Option[String] = pack(jarPath, out, defaultPackerOptions, log)
|
||||
def pack(jarPath: Path, out: Path, options: Map[String, String], log: Logger): Option[String] =
|
||||
{
|
||||
val packer = Pack200.newPacker
|
||||
val properties = new wrap.MutableMapWrapper(packer.properties)
|
||||
properties ++= options
|
||||
|
||||
OpenResource.jarFile(false).ioOption(jarPath.asFile, "applying pack200 compression to jar", log) { f =>
|
||||
writeStream(out.asFile, log) { stream =>
|
||||
packer.pack(f, stream)
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
def unpack(packedPath: Path, toJarPath: Path, log: Logger): Option[String] =
|
||||
{
|
||||
val unpacker = Pack200.newUnpacker
|
||||
writeStream(toJarPath.asFile, log) { fileStream =>
|
||||
val jarOut = new JarOutputStream(fileStream)
|
||||
Control.trapUnitAndFinally("Error unpacking '" + packedPath + "': ", log)
|
||||
{ unpacker.unpack(packedPath.asFile, jarOut); None }
|
||||
{ jarOut.close() }
|
||||
}
|
||||
}
|
||||
def defaultPackerOptions: Map[String, String] = scala.collection.immutable.Map()
|
||||
}
|
||||
|
||||
import java.net.URL
|
||||
/** This is somewhat of a mess and is not entirely correct. jarsigner doesn't work properly
|
||||
* on scalaz and it is difficult to determine whether a jar is both signed and valid. */
|
||||
object SignJar
|
||||
{
|
||||
final class SignOption private[SignJar](val toList: List[String], val signOnly: Boolean) extends NotNull
|
||||
{
|
||||
override def toString = toList.mkString(" ")
|
||||
}
|
||||
def keyStore(url: URL) = new SignOption("-keystore" :: url.toExternalForm :: Nil, true)
|
||||
def signedJar(p: Path) = new SignOption("-signedjar" :: p.asFile.getAbsolutePath :: Nil, true)
|
||||
def verbose = new SignOption("-verbose" :: Nil, false)
|
||||
def sigFile(name: String) = new SignOption("-sigfile" :: name :: Nil, true)
|
||||
def storeType(t: String) = new SignOption("-storetype" :: t :: Nil, false)
|
||||
def provider(p: String) = new SignOption("-provider" :: p :: Nil, false)
|
||||
def providerName(p: String) = new SignOption("-providerName" :: p :: Nil, false)
|
||||
def storePassword(p: String) = new SignOption("-storepass" :: p :: Nil, true)
|
||||
def keyPassword(p: String) = new SignOption("-keypass" :: p :: Nil, true)
|
||||
|
||||
private def VerifyOption = "-verify"
|
||||
|
||||
/** Uses jarsigner to sign the given jar. */
|
||||
def sign(jarPath: Path, alias: String, options: Seq[SignOption], log: Logger): Option[String] =
|
||||
{
|
||||
require(!alias.trim.isEmpty, "Alias cannot be empty")
|
||||
val arguments = options.toList.flatMap(_.toList) ::: jarPath.asFile.getAbsolutePath :: alias :: Nil
|
||||
execute("Signed " + jarPath, "signing", arguments, log)
|
||||
}
|
||||
/** Uses jarsigner to verify the given jar.*/
|
||||
def verify(jarPath: Path, options: Seq[SignOption], log: Logger): Option[String] =
|
||||
{
|
||||
val arguments = options.filter(!_.signOnly).toList.flatMap(_.toList) ::: VerifyOption :: jarPath.asFile.getAbsolutePath :: Nil
|
||||
execute("Verified " + jarPath, "verifying", arguments, log)
|
||||
}
|
||||
private def execute(successMessage: String, action: String, arguments: List[String], log: Logger): Option[String] =
|
||||
{
|
||||
val exitCode = Process(CommandName, arguments) ! log
|
||||
if(exitCode == 0)
|
||||
{
|
||||
log.debug(successMessage)
|
||||
None
|
||||
}
|
||||
else
|
||||
Some("Error " + action + " jar (exit code was " + exitCode + ".)")
|
||||
}
|
||||
|
||||
private val CommandName = "jarsigner"
|
||||
}
|
||||
|
|
@ -0,0 +1,464 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
/** This file provides the parallel execution engine of sbt. It is a fairly general module, with pluggable Schedulers and Strategies.
|
||||
*
|
||||
* There are three main componenets to the engine: Distributors, Schedulers, and Strategies.
|
||||
*
|
||||
* A Scheduler provides work that is ready to execute. The main type of Scheduler in sbt is a scheduler
|
||||
* of nodes in a directed, acyclic graph.. This type of scheduler provides work when its
|
||||
* dependencies have finished executing successfully. Another type of scheduler is a MultiScheduler, which draws work
|
||||
* from sub-schedulers.
|
||||
*
|
||||
* A Strategy is used by a Scheduler to select the work to process from the work that is ready. It is notified as work
|
||||
* becomes ready. It is requested to select work to process from the work that is ready. The main Strategy in sbt is the
|
||||
* OrderedStrategy, which prioritizes work according to some ordering defined by its constructor. The primary ordering
|
||||
* used in sbt is based on the longest length of the processing path that includes the node being ordered.
|
||||
*
|
||||
* A Distributor uses a Scheduler to obtain work according up to the maximum work allowed to run at once. It runs each
|
||||
* unit of work in its own Thread.
|
||||
**/
|
||||
|
||||
import java.util.concurrent.LinkedBlockingQueue
|
||||
import scala.collection.{immutable, mutable}
|
||||
import immutable.TreeSet
|
||||
|
||||
/** Interface to the Distributor/Scheduler system for running tasks with dependencies described by a directed acyclic graph.*/
|
||||
object ParallelRunner
|
||||
{
|
||||
/** Executes work for nodes in an acyclic directed graph with root node `node`. The name of a node is provided
|
||||
* by the `name` function, the work to perform for a node by `action`, and the logger to use for a node by `log`.
|
||||
* The maximum number of tasks to execute simultaneously is `maximumTasks`. */
|
||||
def run[D <: Dag[D]](node: D, name: D => String, action: D => Option[String], maximumTasks: Int, log: D => Logger): List[WorkFailure[D]] =
|
||||
{
|
||||
val info = DagInfo(node)
|
||||
// Create a strategy that gives each node a uniform self cost and uses the maximum cost to execute it and the nodes that depend on it
|
||||
// to determine which node to run. The self cost could be modified to include more information about a node, such as the size of input files
|
||||
val strategy = defaultStrategy(info)
|
||||
val jobScheduler = CompoundScheduler(new DagScheduler(info, strategy), strategy)
|
||||
val distributor = new Distributor(jobScheduler, action, maximumTasks, log)
|
||||
val result = distributor.run().toList
|
||||
for( WorkFailure(work, message) <- result ) yield WorkFailure(work, "Error running " + name(work) + ": " + message)
|
||||
}
|
||||
def dagScheduler[D <: Dag[D]](node: D) =
|
||||
{
|
||||
val info = DagInfo(node)
|
||||
new DagScheduler(info, defaultStrategy(info))
|
||||
}
|
||||
private def defaultStrategy[D <: Dag[D]](info: DagInfo[D]) = MaxPathStrategy((d: D) => 1, info)
|
||||
}
|
||||
/** Requests work from `scheduler` and processes it using `doWork`. This class limits the amount of work processing at any given time
|
||||
* to `workers`.*/
|
||||
final class Distributor[D](scheduler: Scheduler[D], doWork: D => Option[String], workers: Int, log: D => Logger) extends NotNull
|
||||
{
|
||||
require(workers > 0)
|
||||
final def run(): Iterable[WorkFailure[D]] = (new Run).run()
|
||||
|
||||
private final class Run extends NotNull
|
||||
{
|
||||
private[this] val schedule = scheduler.run
|
||||
/** The number of threads currently running. */
|
||||
private[this] var running = 0
|
||||
/** Pending notifications of completed work. */
|
||||
private[this] val complete = new java.util.concurrent.LinkedBlockingQueue[Done]
|
||||
|
||||
private[Distributor] def run(): Iterable[WorkFailure[D]] =
|
||||
{
|
||||
next()
|
||||
if(isIdle && !schedule.hasPending) // test if all work is complete
|
||||
schedule.failures
|
||||
else
|
||||
{
|
||||
waitForCompletedWork() // wait for some work to complete
|
||||
run() // continue
|
||||
}
|
||||
}
|
||||
// true if the maximum number of worker threads are currently running
|
||||
private def atMaximum = running == workers
|
||||
private def availableWorkers = workers - running
|
||||
// true if no worker threads are currently running
|
||||
private def isIdle = running == 0
|
||||
// process more work
|
||||
private def next()
|
||||
{
|
||||
// if the maximum threads are being used, do nothing
|
||||
// if all work is complete or the scheduler is waiting for current work to complete, do nothing
|
||||
if(!atMaximum && schedule.hasPending)
|
||||
{
|
||||
val nextWork = schedule.next(availableWorkers)
|
||||
val nextSize = nextWork.size
|
||||
assume(nextSize <= availableWorkers, "Scheduler provided more work (" + nextSize + ") than allowed (" + availableWorkers + ")")
|
||||
assume(nextSize > 0 || !isIdle, "Distributor idle and the scheduler indicated work pending, but provided no work.")
|
||||
nextWork.foreach(process)
|
||||
}
|
||||
}
|
||||
// wait on the blocking queue `complete` until some work finishes and notify the scheduler
|
||||
private def waitForCompletedWork()
|
||||
{
|
||||
require(running > 0)
|
||||
val done = complete.take()
|
||||
running -= 1
|
||||
schedule.complete(done.data, done.result)
|
||||
}
|
||||
private def process(data: D)
|
||||
{
|
||||
require(running + 1 <= workers)
|
||||
running += 1
|
||||
new Worker(data).start()
|
||||
}
|
||||
private class Worker(data: D) extends Thread with NotNull
|
||||
{
|
||||
override def run()
|
||||
{
|
||||
val result = Control.trapUnit("", log(data))(doWork(data))
|
||||
complete.put( new Done(result, data) )
|
||||
}
|
||||
}
|
||||
}
|
||||
private final class Done(val result: Option[String], val data: D) extends NotNull
|
||||
}
|
||||
final case class WorkFailure[D](work: D, message: String) extends NotNull
|
||||
{
|
||||
override def toString = message
|
||||
}
|
||||
/** Schedules work of type D. A Scheduler determines what work is ready to be processed.
|
||||
* A Scheduler is itself immutable. It creates a mutable object for each scheduler run.*/
|
||||
trait Scheduler[D] extends NotNull
|
||||
{
|
||||
/** Starts a new run. The returned object is a new Run, representing a single scheduler run. All state for the run
|
||||
* is encapsulated in this object.*/
|
||||
def run: Run
|
||||
trait Run extends NotNull
|
||||
{
|
||||
/** Notifies this scheduler that work has completed with the given result (Some with the error message or None if the work succeeded).*/
|
||||
def complete(d: D, result: Option[String]): Unit
|
||||
/** Returns true if there is any more work to be done, although remaining work can be blocked
|
||||
* waiting for currently running work to complete.*/
|
||||
def hasPending: Boolean
|
||||
/**Returns true if this scheduler has no more work to be done, ever.*/
|
||||
def isComplete: Boolean
|
||||
/** Returns up to 'max' units of work. `max` is always positive. The returned sequence cannot be empty if there is
|
||||
* no work currently being processed.*/
|
||||
def next(max: Int): Seq[D]
|
||||
/** A list of failures that occurred to this point, as reported to the `complete` method. */
|
||||
def failures: Iterable[WorkFailure[D]]
|
||||
}
|
||||
}
|
||||
/** A Strategy selects the work to process from work that is ready to be processed.*/
|
||||
private trait ScheduleStrategy[D] extends NotNull
|
||||
{
|
||||
/** Starts a new run. The returned object is a new Run, representing a single strategy run. All state for the run
|
||||
* is handled through this object and is encapsulated in this object.*/
|
||||
def run: Run
|
||||
trait Run extends NotNull
|
||||
{
|
||||
/** Adds the given work to the list of work that is ready to run.*/
|
||||
def workReady(dep: D): Unit
|
||||
/** Returns true if there is work ready to be run. */
|
||||
def hasReady: Boolean
|
||||
/** Provides up to `max` units of work. `max` is always positive and this method is not called
|
||||
* if hasReady is false. The returned list cannot be empty is there is work ready to be run.*/
|
||||
def next(max: Int): List[D]
|
||||
}
|
||||
}
|
||||
|
||||
/** A scheduler for nodes of a directed-acyclic graph. It requires the root of the graph
|
||||
* and a strategy to select which available nodes to run on limited resources.*/
|
||||
private[sbt] final class DagScheduler[D <: Dag[D]](info: DagInfo[D], strategy: ScheduleStrategy[D]) extends Scheduler[D]
|
||||
{
|
||||
def run: Run = new Run
|
||||
{
|
||||
val infoRun = info.run
|
||||
val strategyRun = strategy.run
|
||||
|
||||
// find nodes that are ready to be run (no dependencies)
|
||||
{
|
||||
val startReady = for( (key, value) <- infoRun.remainingDepsRun if(value.isEmpty)) yield key
|
||||
infoRun.remainingDepsRun --= startReady
|
||||
startReady.foreach(strategyRun.workReady)
|
||||
}
|
||||
|
||||
val failures = new mutable.ListBuffer[WorkFailure[D]]
|
||||
def next(max: Int) = strategyRun.next(max)
|
||||
def complete(work: D, result: Option[String])
|
||||
{
|
||||
result match
|
||||
{
|
||||
case None => infoRun.complete(work, strategyRun.workReady)
|
||||
case Some(errorMessage) =>
|
||||
infoRun.clear(work)
|
||||
failures += WorkFailure(work, errorMessage)
|
||||
}
|
||||
}
|
||||
def isComplete = !strategyRun.hasReady && infoRun.reverseDepsRun.isEmpty
|
||||
// the strategy might not have any work ready if the remaining work needs currently executing work to finish first
|
||||
def hasPending = strategyRun.hasReady || !infoRun.remainingDepsRun.isEmpty
|
||||
}
|
||||
}
|
||||
private object MaxPathStrategy
|
||||
{
|
||||
def apply[D <: Dag[D]](selfCost: D => Int, info: DagInfo[D]): ScheduleStrategy[D] =
|
||||
{
|
||||
val cost = // compute the cost of the longest execution path ending at each node
|
||||
{
|
||||
val cost = new mutable.HashMap[D, Int]
|
||||
def computeCost(work: D): Int = info.reverseDeps.getOrElse(work, immutable.Set.empty[D]).foldLeft(0)(_ max getCost(_)) + selfCost(work)
|
||||
def getCost(work: D): Int = cost.getOrElseUpdate(work, computeCost(work))
|
||||
info.remainingDeps.keys.foreach(getCost)
|
||||
wrap.Wrappers.readOnly(cost)
|
||||
}
|
||||
// create a function to compare units of work. This is not as simple as cost(a) compare cost(b) because it cannot return 0 for
|
||||
// unequal nodes (at least for the Ordered comparison)
|
||||
|
||||
// 2.8.0 uses Ordering
|
||||
implicit val compareOrdering: Ordering[D] =
|
||||
new Ordering[D]
|
||||
{
|
||||
def compare(a: D, b: D) =
|
||||
{
|
||||
val base = cost(a) compare cost(b)
|
||||
if(base == 0)
|
||||
a.hashCode compare b.hashCode // this is required because TreeSet interprets 0 as equal
|
||||
else
|
||||
base
|
||||
}
|
||||
}
|
||||
// 2.7.x uses an implicit view to Ordered
|
||||
implicit val compare =
|
||||
(a: D) => new Ordered[D] {
|
||||
def compare(b: D) = compareOrdering.compare(a, b)
|
||||
}
|
||||
new OrderedStrategy(new TreeSet())
|
||||
}
|
||||
}
|
||||
/** A strategy that adds work to a tree and selects the last key as the next work to be done. */
|
||||
private class OrderedStrategy[D](ready: TreeSet[D]) extends ScheduleStrategy[D]
|
||||
{
|
||||
def run = new Run
|
||||
{
|
||||
private[this] var readyRun = ready
|
||||
def next(max: Int): List[D] = nextImpl(max, Nil)
|
||||
private[this] def nextImpl(remaining: Int, accumulated: List[D]): List[D] =
|
||||
{
|
||||
if(remaining <= 0 || readyRun.isEmpty)
|
||||
accumulated
|
||||
else
|
||||
{
|
||||
val next = readyRun.lastKey
|
||||
readyRun -= next
|
||||
nextImpl(remaining - 1, next :: accumulated)
|
||||
}
|
||||
}
|
||||
def workReady(dep: D) { readyRun += dep }
|
||||
def hasReady = !readyRun.isEmpty
|
||||
}
|
||||
}
|
||||
/** A class that represents state for a DagScheduler and that MaxPathStrategy uses to initialize an OrderedStrategy. */
|
||||
private final class DagInfo[D <: Dag[D]](val remainingDeps: immutable.Map[D, immutable.Set[D]],
|
||||
val reverseDeps: immutable.Map[D, immutable.Set[D]]) extends NotNull
|
||||
{
|
||||
def run = new Run
|
||||
final class Run extends NotNull
|
||||
{
|
||||
val remainingDepsRun = DagInfo.mutableMap(remainingDeps)
|
||||
val reverseDepsRun = DagInfo.mutableMap(reverseDeps)
|
||||
/** Called when work does not complete successfully and so all work that (transitively) depends on the work
|
||||
* must be removed from the maps. */
|
||||
def clear(work: D)
|
||||
{
|
||||
remainingDepsRun -= work
|
||||
foreachReverseDep(work)(clear)
|
||||
}
|
||||
/** Called when work completes properly. `initial` and `ready` are used for a fold over
|
||||
* the work that is now ready to go (becaues it was only waiting for `work` to complete).*/
|
||||
def complete(work: D, ready: D => Unit)
|
||||
{
|
||||
def completed(dependsOnCompleted: D)
|
||||
{
|
||||
for(remainingDependencies <- remainingDepsRun.get(dependsOnCompleted))
|
||||
{
|
||||
remainingDependencies -= work
|
||||
if(remainingDependencies.isEmpty)
|
||||
{
|
||||
remainingDepsRun -= dependsOnCompleted
|
||||
ready(dependsOnCompleted)
|
||||
}
|
||||
}
|
||||
}
|
||||
foreachReverseDep(work)(completed)
|
||||
}
|
||||
private def foreachReverseDep(work: D)(f: D => Unit) { reverseDepsRun.removeKey(work).foreach(_.foreach(f)) }
|
||||
}
|
||||
}
|
||||
/** Constructs forward and reverse dependency map for the given Dag root node. */
|
||||
private object DagInfo
|
||||
{
|
||||
/** Constructs the reverse dependency map from the given Dag and
|
||||
* puts the forward dependencies into a map */
|
||||
def apply[D <: Dag[D]](root: D): DagInfo[D] =
|
||||
{
|
||||
val remainingDeps = new mutable.HashMap[D, immutable.Set[D]]
|
||||
val reverseDeps = new mutable.HashMap[D, mutable.Set[D]]
|
||||
def visitIfUnvisited(node: D): Unit = remainingDeps.getOrElseUpdate(node, processDependencies(node))
|
||||
def processDependencies(node: D): Set[D] =
|
||||
{
|
||||
val workDependencies = node.dependencies
|
||||
workDependencies.foreach(visitIfUnvisited)
|
||||
for(dep <- workDependencies)
|
||||
reverseDeps.getOrElseUpdate(dep, new mutable.HashSet[D]) += node
|
||||
immutable.HashSet(workDependencies.toSeq: _*)
|
||||
}
|
||||
visitIfUnvisited(root)
|
||||
new DagInfo(immutable.HashMap(remainingDeps.toSeq : _*), immute(reverseDeps) )
|
||||
}
|
||||
/** Convert a mutable Map with mutable Sets for values to an immutable Map with immutable Sets for values. */
|
||||
private def immute[D](map: mutable.Map[D, mutable.Set[D]]): immutable.Map[D, immutable.Set[D]] =
|
||||
{
|
||||
val immutedSets = map.map { case (key, value) =>(key, immutable.HashSet(value.toSeq : _*)) }
|
||||
immutable.HashMap(immutedSets.toSeq :_*)
|
||||
}
|
||||
/** Convert an immutable Map with immutable Sets for values to a mutable Map with mutable Sets for values. */
|
||||
private def mutableMap[D](map: immutable.Map[D, immutable.Set[D]]): mutable.Map[D, mutable.Set[D]] =
|
||||
{
|
||||
val mutableSets = map.map { case (key, value) =>(key, mutable.HashSet(value.toSeq : _*)) }
|
||||
mutable.HashMap(mutableSets.toSeq :_*)
|
||||
}
|
||||
}
|
||||
/** A scheduler that can get work from sub-schedulers. The `schedulers` argument to the constructor
|
||||
* is a sequence of the initial schedulers and the key to provide to a client that uses the 'detailedComplete'
|
||||
* method when the scheduler completes its work.*/
|
||||
private final class MultiScheduler[D, T](schedulers: (Scheduler[D], T)*) extends Scheduler[D]
|
||||
{
|
||||
/** Returns a Run instance that represents a scheduler run.*/
|
||||
def run = new MultiRun
|
||||
final class MultiRun extends Run
|
||||
{
|
||||
val owners = new mutable.HashMap[D, Scheduler[D]#Run]
|
||||
val failures = new mutable.ListBuffer[WorkFailure[D]]
|
||||
val schedules = mutable.HashMap[Scheduler[D]#Run, T](schedulers.map { case (scheduler, completeKey) => (scheduler.run, completeKey)} : _*)
|
||||
def +=(schedule: Scheduler[D]#Run, completeKey: T) { schedules(schedule) = completeKey }
|
||||
|
||||
def isComplete = schedules.keys.forall(_.isComplete)
|
||||
def hasPending = schedules.keys.exists(_.hasPending)
|
||||
def next(max: Int) = nextImpl(max, schedules.keys.toList, Nil)
|
||||
|
||||
private def nextImpl(max: Int, remaining: List[Scheduler[D]#Run], accumulatedWork: List[D]): Seq[D] =
|
||||
{
|
||||
if(max == 0 || remaining.isEmpty)
|
||||
accumulatedWork
|
||||
else
|
||||
{
|
||||
val currentSchedule = remaining.head
|
||||
if(currentSchedule.hasPending)
|
||||
{
|
||||
val newWork = currentSchedule.next(max).toList
|
||||
newWork.foreach(work => owners.put(work, currentSchedule))
|
||||
nextImpl(max - newWork.size, remaining.tail, newWork ::: accumulatedWork)
|
||||
}
|
||||
else
|
||||
nextImpl(max, remaining.tail, accumulatedWork)
|
||||
}
|
||||
}
|
||||
|
||||
def complete(work: D, result: Option[String]) { detailedComplete(work, result) }
|
||||
def detailedComplete(work: D, result: Option[String]) =
|
||||
{
|
||||
def complete(forOwner: Scheduler[D]#Run) =
|
||||
{
|
||||
forOwner.complete(work, result)
|
||||
if(forOwner.isComplete)
|
||||
{
|
||||
failures ++= forOwner.failures
|
||||
Some(forOwner, schedules.removeKey(forOwner).get)
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
owners.removeKey(work).flatMap(complete)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** This scheduler allows a unit of work to provide nested work.
|
||||
*
|
||||
* When a unit of work that implements CompoundWork is returned for processing by `multi`, this scheduler will request the work's
|
||||
* nested scheduler that represents the nested work to be done. The new scheduler will be added to `multi`. When the new scheduler
|
||||
* is finished providing work, a final scheduler is run.*/
|
||||
private final class CompoundScheduler[D](multi: MultiScheduler[D, Option[FinalWork[D]]], finalWorkStrategy: ScheduleStrategy[D]) extends Scheduler[D]
|
||||
{
|
||||
def run: Run = new Run
|
||||
{
|
||||
val multiRun = multi.run
|
||||
val strategyRun = finalWorkStrategy.run
|
||||
|
||||
def isComplete = multiRun.isComplete && !strategyRun.hasReady
|
||||
def hasPending = strategyRun.hasReady || multiRun.hasPending || multiRun.schedules.values.exists(_.isDefined)
|
||||
def complete(work: D, result: Option[String]) =
|
||||
{
|
||||
for( (scheduler, Some(finalWorkTodo)) <- multiRun.detailedComplete(work, result) )
|
||||
{
|
||||
multiRun += (finalWorkTodo.doFinally.run, None)
|
||||
if(scheduler.failures.isEmpty)
|
||||
strategyRun workReady finalWorkTodo.compound
|
||||
else
|
||||
multiRun.complete(finalWorkTodo.compound, Some("One or more subtasks failed"))
|
||||
}
|
||||
}
|
||||
def failures = multiRun.failures
|
||||
def next(max: Int) = nextImpl(max, Nil)
|
||||
private def nextImpl(max: Int, processedNextWork: List[D]): Seq[D] =
|
||||
{
|
||||
if(max > 0)
|
||||
{
|
||||
if(strategyRun.hasReady)
|
||||
{
|
||||
val newWork = strategyRun.next(max)
|
||||
nextImpl(max - newWork.size, newWork ::: processedNextWork)
|
||||
}
|
||||
else if(multiRun.hasPending)
|
||||
{
|
||||
val multiWork = multiRun.next(max)
|
||||
if(multiWork.isEmpty)
|
||||
processedNextWork
|
||||
else
|
||||
{
|
||||
val expandedWork = (processedNextWork /: multiWork)(expand)
|
||||
val remaining = max - (expandedWork.size - processedNextWork.size)
|
||||
nextImpl(remaining, expandedWork)
|
||||
}
|
||||
}
|
||||
else
|
||||
processedNextWork
|
||||
}
|
||||
else
|
||||
processedNextWork
|
||||
}
|
||||
private def expand(accumulate: List[D], work: D): List[D] =
|
||||
{
|
||||
work match
|
||||
{
|
||||
case c: CompoundWork[D] =>
|
||||
val subWork = c.work
|
||||
addFinal(subWork.scheduler, new FinalWork(work, subWork.doFinally))
|
||||
accumulate
|
||||
case _ => work :: accumulate
|
||||
}
|
||||
}
|
||||
private def addFinal(schedule: Scheduler[D], work: FinalWork[D]) { multiRun += (schedule.run, Some(work)) }
|
||||
}
|
||||
}
|
||||
private object CompoundScheduler
|
||||
{
|
||||
def apply[D](scheduler: Scheduler[D], strategy: ScheduleStrategy[D]) : Scheduler[D] =
|
||||
new CompoundScheduler(new MultiScheduler[D, Option[FinalWork[D]]]( (scheduler, None) ), strategy)
|
||||
}
|
||||
private final class FinalWork[D](val compound: D, val doFinally: Scheduler[D]) extends NotNull
|
||||
/** This represents nested work. The work provided by `scheduler` is processed first. The work provided by `doFinally` is processed
|
||||
* after `scheduler` completes regardless of the success of `scheduler`.*/
|
||||
final class SubWork[D](val scheduler: Scheduler[D], val doFinally: Scheduler[D]) extends NotNull
|
||||
/** Work that implements this interface provides nested work to be done before this work is processed.*/
|
||||
trait CompoundWork[D] extends NotNull
|
||||
{
|
||||
def work: SubWork[D]
|
||||
}
|
||||
|
|
@ -0,0 +1,336 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import Path._
|
||||
import FileUtilities.wrapNull
|
||||
import java.io.File
|
||||
import scala.collection.mutable.{Set, HashSet}
|
||||
|
||||
/** A Path represents a file in a project.
|
||||
* @see sbt.PathFinder*/
|
||||
sealed abstract class Path extends PathFinder with NotNull
|
||||
{
|
||||
/** Creates a base directory for this path. This is used by copy and zip functions
|
||||
* to determine the relative path that should be used in the destination. For example,
|
||||
* if the following path is specified to be copied to directory 'd',
|
||||
*
|
||||
* <code>((a / b) ##) / x / y</code>
|
||||
*
|
||||
* the copied path would be
|
||||
*
|
||||
* <code>d / x / y</code>
|
||||
*
|
||||
* The <code>relativePath</code> method is used to return the relative path to the base directory. */
|
||||
override def ## : Path = new BaseDirectory(this)
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
{
|
||||
if(asFile.exists)
|
||||
pathSet += this
|
||||
}
|
||||
override def / (component: String): Path = if(component == ".") this else new RelativePath(this, component)
|
||||
/** True if and only if the file represented by this path exists.*/
|
||||
def exists = asFile.exists
|
||||
/** True if and only if the file represented by this path is a directory.*/
|
||||
def isDirectory = asFile.isDirectory
|
||||
/** The last modified time of the file represented by this path.*/
|
||||
def lastModified = asFile.lastModified
|
||||
/* True if and only if file that this path represents exists and the file represented by the path 'p'
|
||||
* does not exist or was modified before the file for this path.*/
|
||||
def newerThan(p: Path): Boolean = exists && (!p.exists || lastModified > p.lastModified)
|
||||
/* True if and only if file that this path represents does not exist or the file represented by the path 'p'
|
||||
* exists and was modified after the file for this path.*/
|
||||
def olderThan(p: Path): Boolean = p newerThan this
|
||||
/** The file represented by this path.*/
|
||||
def asFile: File
|
||||
/** The file represented by this path converted to a <code>URL</code>.*/
|
||||
def asURL = asFile.toURI.toURL
|
||||
/** The string representation of this path relative to the base directory. The project directory is the
|
||||
* default base directory if one is not specified explicitly using the <code>##</code> operator.*/
|
||||
lazy val relativePath: String = relativePathString(sep.toString)
|
||||
def relativePathString(separator: String): String
|
||||
final def projectRelativePath: String = projectRelativePathString(sep.toString)
|
||||
def projectRelativePathString(separator: String): String
|
||||
def absolutePath: String = asFile.getAbsolutePath
|
||||
private[sbt] def prependTo(s: String): String
|
||||
|
||||
/** Equality of Paths is defined in terms of the underlying <code>File</code>.*/
|
||||
override final def equals(other: Any) =
|
||||
other match
|
||||
{
|
||||
case op: Path => asFile == op.asFile
|
||||
case _ => false
|
||||
}
|
||||
/** The hash code of a Path is that of the underlying <code>File</code>.*/
|
||||
override final def hashCode = asFile.hashCode
|
||||
}
|
||||
private final class BaseDirectory(private[sbt] val path: Path) extends Path
|
||||
{
|
||||
override def ## : Path = this
|
||||
override def toString = path.toString
|
||||
def asFile = path.asFile
|
||||
def relativePathString(separator: String) = ""
|
||||
def projectRelativePathString(separator: String) = path.projectRelativePathString(separator)
|
||||
private[sbt] def prependTo(s: String) = "." + sep + s
|
||||
}
|
||||
private[sbt] final class FilePath(file: File) extends Path
|
||||
{
|
||||
lazy val asFile = absolute(file)
|
||||
override def toString = absolutePath
|
||||
def relativePathString(separator: String) = asFile.getName
|
||||
def projectRelativePathString(separator: String) = relativePathString(separator)
|
||||
private[sbt] def prependTo(s: String) = absolutePath + sep + s
|
||||
}
|
||||
private[sbt] final class ProjectDirectory(file: File) extends Path
|
||||
{
|
||||
lazy val asFile = absolute(file)
|
||||
override def toString = "."
|
||||
def relativePathString(separator: String) = ""
|
||||
def projectRelativePathString(separator: String) = ""
|
||||
private[sbt] def prependTo(s: String) = "." + sep + s
|
||||
}
|
||||
private[sbt] final class RelativePath(val parentPath: Path, val component: String) extends Path
|
||||
{
|
||||
checkComponent(component)
|
||||
override def toString = parentPath prependTo component
|
||||
lazy val asFile = new File(parentPath.asFile, component)
|
||||
private[sbt] def prependTo(s: String) = parentPath prependTo (component + sep + s)
|
||||
def relativePathString(separator: String) = relative(parentPath.relativePathString(separator), separator)
|
||||
def projectRelativePathString(separator: String) = relative(parentPath.projectRelativePathString(separator), separator)
|
||||
private def relative(parentRelative: String, separator: String) =
|
||||
{
|
||||
if(parentRelative.isEmpty)
|
||||
component
|
||||
else
|
||||
parentRelative + separator + component
|
||||
}
|
||||
}
|
||||
object Path
|
||||
{
|
||||
import java.io.File
|
||||
import File.pathSeparator
|
||||
|
||||
def fileProperty(name: String) = Path.fromFile(System.getProperty(name))
|
||||
def userHome = fileProperty("user.home")
|
||||
|
||||
def absolute(file: File) = new File(file.toURI.normalize).getAbsoluteFile
|
||||
/** Constructs a String representation of <code>Path</code>s. The absolute path String of each <code>Path</code> is
|
||||
* separated by the platform's path separator.*/
|
||||
def makeString(paths: Iterable[Path]): String = paths.map(_.absolutePath).mkString(pathSeparator)
|
||||
|
||||
/** Constructs a String representation of <code>Path</code>s. The relative path String of each <code>Path</code> is
|
||||
* separated by the platform's path separator.*/
|
||||
def makeRelativeString(paths: Iterable[Path]): String = makeRelativeString(paths, sep.toString)
|
||||
def makeRelativeString(paths: Iterable[Path], separator: String): String = paths.map(_.relativePathString(separator)).mkString(pathSeparator)
|
||||
|
||||
def splitString(projectPath: Path, value: String): Iterable[Path] =
|
||||
{
|
||||
for(pathString <- FileUtilities.pathSplit(value) if pathString.length > 0) yield
|
||||
Path.fromString(projectPath, pathString)
|
||||
}
|
||||
|
||||
/** A <code>PathFinder</code> that always produces the empty set of <code>Path</code>s.*/
|
||||
def emptyPathFinder =
|
||||
new PathFinder
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path]) {}
|
||||
}
|
||||
/** A <code>PathFinder</code> that selects the paths provided by the <code>paths</code> argument, which is
|
||||
* reevaluated on each call to the <code>PathFinder</code>'s <code>get</code> method. */
|
||||
def lazyPathFinder(paths: => Iterable[Path]): PathFinder =
|
||||
new PathFinder
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path]) = pathSet ++= paths
|
||||
}
|
||||
|
||||
/** The separator character of the platform.*/
|
||||
val sep = java.io.File.separatorChar
|
||||
|
||||
/** Checks the string to verify that it is a legal path component. The string must be non-empty,
|
||||
* not a slash, and not '.' or '..'.*/
|
||||
def checkComponent(c: String): String =
|
||||
{
|
||||
require(c.length > 0, "Path component must not be empty")
|
||||
require(c.indexOf('/') == -1, "Path component '" + c + "' must not have forward slashes in it")
|
||||
require(c.indexOf('\\') == -1, "Path component '" + c + "' must not have backslashes in it")
|
||||
require(c != "..", "Path component cannot be '..'")
|
||||
require(c != ".", "Path component cannot be '.'")
|
||||
c
|
||||
}
|
||||
/** Converts a path string relative to the given base path to a <code>Path</code>. */
|
||||
def fromString(basePath: Path, value: String): Path =
|
||||
{
|
||||
if(value.isEmpty)
|
||||
basePath
|
||||
else
|
||||
{
|
||||
val components = value.split("""[/\\]""")
|
||||
(basePath /: components)( (path, component) => path / component )
|
||||
}
|
||||
}
|
||||
def baseAncestor(path: Path): Option[Path] =
|
||||
path match
|
||||
{
|
||||
case pd: ProjectDirectory => None
|
||||
case fp: FilePath => None
|
||||
case rp: RelativePath => baseAncestor(rp.parentPath)
|
||||
case b: BaseDirectory => Some(b.path)
|
||||
}
|
||||
|
||||
def relativize(basePath: Path, path: Path): Option[Path] = relativize(basePath, path.asFile)
|
||||
def relativize(basePath: Path, file: File): Option[Path] =
|
||||
basePathString(basePath) flatMap { baseString => relativize(basePath, baseString, file) }
|
||||
def relativize(basePath: Path, basePathString: String, file: File): Option[Path] =
|
||||
{
|
||||
val pathString = file.getAbsolutePath
|
||||
if(pathString.startsWith(basePathString))
|
||||
Some(fromString(basePath, pathString.substring(basePathString.length)))
|
||||
else
|
||||
None
|
||||
}
|
||||
private[sbt] def relativize(baseFile: File, file: File): Option[String] =
|
||||
{
|
||||
val pathString = file.getAbsolutePath
|
||||
baseFileString(baseFile) flatMap
|
||||
{
|
||||
baseString =>
|
||||
{
|
||||
if(pathString.startsWith(baseString))
|
||||
Some(pathString.substring(baseString.length))
|
||||
else
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
private[sbt] def basePathString(basePath: Path): Option[String] = baseFileString(basePath.asFile)
|
||||
private def baseFileString(baseFile: File): Option[String] =
|
||||
{
|
||||
if(baseFile.isDirectory)
|
||||
{
|
||||
val cp = baseFile.getAbsolutePath
|
||||
assert(cp.length > 0)
|
||||
if(cp.charAt(cp.length - 1) == File.separatorChar)
|
||||
Some(cp)
|
||||
else
|
||||
Some(cp + File.separatorChar)
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
def fromFile(file: String): Path = fromFile(new File(file))
|
||||
def fromFile(file: File): Path = new FilePath(file)
|
||||
}
|
||||
|
||||
/** A path finder constructs a set of paths. The set is evaluated by a call to the <code>get</code>
|
||||
* method. The set will be different for different calls to <code>get</code> if the underlying filesystem
|
||||
* has changed.*/
|
||||
sealed abstract class PathFinder extends NotNull
|
||||
{
|
||||
/** The union of the paths found by this <code>PathFinder</code> with the paths found by 'paths'.*/
|
||||
def +++(paths: PathFinder): PathFinder = new Paths(this, paths)
|
||||
/** Excludes all paths from <code>excludePaths</code> from the paths selected by this <code>PathFinder</code>.*/
|
||||
def ---(excludePaths: PathFinder): PathFinder = new ExcludePaths(this, excludePaths)
|
||||
/** Constructs a new finder that selects all paths with a name that matches <code>filter</code> and are
|
||||
* descendents of paths selected by this finder.*/
|
||||
def **(filter: FileFilter): PathFinder = new DescendentOrSelfPathFinder(this, filter)
|
||||
/** Constructs a new finder that selects all paths with a name that matches <code>filter</code> and are
|
||||
* immediate children of paths selected by this finder.*/
|
||||
def *(filter: FileFilter): PathFinder = new ChildPathFinder(this, filter)
|
||||
/** Constructs a new finder that selects all paths with name <code>literal</code> that are immediate children
|
||||
* of paths selected by this finder.*/
|
||||
def / (literal: String): PathFinder = new ChildPathFinder(this, new ExactFilter(literal))
|
||||
/** Constructs a new finder that selects all paths with name <code>literal</code> that are immediate children
|
||||
* of paths selected by this finder.*/
|
||||
final def \ (literal: String): PathFinder = this / literal
|
||||
|
||||
/** Makes the paths selected by this finder into base directories.
|
||||
* @see Path.##
|
||||
*/
|
||||
def ## : PathFinder = new BasePathFinder(this)
|
||||
|
||||
/** Selects all descendent paths with a name that matches <code>include</code> and do not have an intermediate
|
||||
* path with a name that matches <code>intermediateExclude</code>. Typical usage is:
|
||||
*
|
||||
* <code>descendentsExcept("*.jar", ".svn")</code>*/
|
||||
def descendentsExcept(include: FileFilter, intermediateExclude: FileFilter): PathFinder =
|
||||
(this ** include) --- (this ** intermediateExclude ** include)
|
||||
|
||||
/** Evaluates this finder. The set returned by this method will reflect the underlying filesystem at the
|
||||
* time of calling. If the filesystem changes, two calls to this method might be different.*/
|
||||
final def get: scala.collection.Set[Path] =
|
||||
{
|
||||
val pathSet = new HashSet[Path]
|
||||
addTo(pathSet)
|
||||
wrap.Wrappers.readOnly(pathSet)
|
||||
}
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
}
|
||||
private class BasePathFinder(base: PathFinder) extends PathFinder
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
{
|
||||
for(path <- base.get)
|
||||
pathSet += (path ##)
|
||||
}
|
||||
}
|
||||
private abstract class FilterPath extends PathFinder with FileFilter
|
||||
{
|
||||
def parent: PathFinder
|
||||
def filter: FileFilter
|
||||
final def accept(file: File) = filter.accept(file)
|
||||
|
||||
protected def handlePath(path: Path, pathSet: Set[Path])
|
||||
{
|
||||
for(matchedFile <- wrapNull(path.asFile.listFiles(this)))
|
||||
pathSet += path / matchedFile.getName
|
||||
}
|
||||
}
|
||||
private class DescendentOrSelfPathFinder(val parent: PathFinder, val filter: FileFilter) extends FilterPath
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
{
|
||||
for(path <- parent.get)
|
||||
{
|
||||
if(accept(path.asFile))
|
||||
pathSet += path
|
||||
handlePathDescendent(path, pathSet)
|
||||
}
|
||||
}
|
||||
private def handlePathDescendent(path: Path, pathSet: Set[Path])
|
||||
{
|
||||
handlePath(path, pathSet)
|
||||
for(childDirectory <- wrapNull(path.asFile.listFiles(DirectoryFilter)))
|
||||
handlePathDescendent(path / childDirectory.getName, pathSet)
|
||||
}
|
||||
}
|
||||
private class ChildPathFinder(val parent: PathFinder, val filter: FileFilter) extends FilterPath
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
{
|
||||
for(path <- parent.get)
|
||||
handlePath(path, pathSet)
|
||||
}
|
||||
}
|
||||
private class Paths(a: PathFinder, b: PathFinder) extends PathFinder
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
{
|
||||
a.addTo(pathSet)
|
||||
b.addTo(pathSet)
|
||||
}
|
||||
}
|
||||
private class ExcludePaths(include: PathFinder, exclude: PathFinder) extends PathFinder
|
||||
{
|
||||
private[sbt] def addTo(pathSet: Set[Path])
|
||||
{
|
||||
val includeSet = new HashSet[Path]
|
||||
include.addTo(includeSet)
|
||||
|
||||
val excludeSet = new HashSet[Path]
|
||||
exclude.addTo(excludeSet)
|
||||
|
||||
includeSet --= excludeSet
|
||||
pathSet ++= includeSet
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.lang.{Process => JProcess, ProcessBuilder => JProcessBuilder}
|
||||
import java.io.{Closeable, File, IOException}
|
||||
import java.io.{BufferedReader, InputStream, InputStreamReader, OutputStream, PipedInputStream, PipedOutputStream}
|
||||
import java.net.URL
|
||||
|
||||
/** Methods for constructing simple commands that can then be combined. */
|
||||
object Process
|
||||
{
|
||||
implicit def apply(command: String): ProcessBuilder = apply(command.split("""\s+""")) // TODO: use CommandParser
|
||||
implicit def apply(command: Seq[String]): ProcessBuilder = apply(new JProcessBuilder(command.toArray : _*))
|
||||
def apply(command: String, arguments: Seq[String]): ProcessBuilder = apply(new JProcessBuilder((command :: arguments.toList).toArray : _*))
|
||||
implicit def apply(builder: JProcessBuilder): ProcessBuilder = new SimpleProcessBuilder(builder)
|
||||
implicit def apply(file: File): FilePartialBuilder = new FileBuilder(file)
|
||||
implicit def apply(url: URL): URLPartialBuilder = new URLBuilder(url)
|
||||
}
|
||||
|
||||
trait URLPartialBuilder extends NotNull
|
||||
{
|
||||
def #>(b: ProcessBuilder): ProcessBuilder
|
||||
def #>>(b: File): ProcessBuilder
|
||||
def #>(b: File): ProcessBuilder
|
||||
}
|
||||
trait FilePartialBuilder extends NotNull
|
||||
{
|
||||
def #>(b: ProcessBuilder): ProcessBuilder
|
||||
def #<(b: ProcessBuilder): ProcessBuilder
|
||||
def #<(url: URL): ProcessBuilder
|
||||
def #>>(b: File): ProcessBuilder
|
||||
def #>(b: File): ProcessBuilder
|
||||
def #<(file: File): ProcessBuilder
|
||||
def #<<(file: File): ProcessBuilder
|
||||
}
|
||||
|
||||
/** Represents a process that is running or has finished running.
|
||||
* It may be a compound process with several underlying native processes (such as 'a #&& b`).*/
|
||||
trait Process extends NotNull
|
||||
{
|
||||
/** Blocks until this process exits and returns the exit code.*/
|
||||
def exitValue(): Int
|
||||
/** Destroys this process. */
|
||||
def destroy(): Unit
|
||||
}
|
||||
/** Represents a runnable process. */
|
||||
trait ProcessBuilder extends NotNull
|
||||
{
|
||||
/** Starts the process represented by this builder, blocks until it exits, and returns the exit code. Standard output and error are
|
||||
* sent to the console.*/
|
||||
def ! : Int
|
||||
/** Starts the process represented by this builder, blocks until it exits, and returns the exit code. Standard output and error are
|
||||
* sent to the given Logger.*/
|
||||
def !(log: Logger): Int
|
||||
/** Starts the process represented by this builder. Standard output and error are sent to the console.*/
|
||||
def run(): Process
|
||||
/** Starts the process represented by this builder. Standard output and error are sent to the given Logger.*/
|
||||
def run(log: Logger): Process
|
||||
/** Starts the process represented by this builder. I/O is handled by the given ProcessIO instance.*/
|
||||
def run(io: ProcessIO): Process
|
||||
|
||||
/** Constructs a command that runs this command first and then `other` if this command succeeds.*/
|
||||
def #&& (other: ProcessBuilder): ProcessBuilder
|
||||
/** Constructs a command that runs this command first and then `other` if this command does not succeed.*/
|
||||
def #|| (other: ProcessBuilder): ProcessBuilder
|
||||
/** Constructs a command that will run this command and pipes the output to `other`. `other` must be a simple command.*/
|
||||
def #| (other: ProcessBuilder): ProcessBuilder
|
||||
/** Constructs a command that will run this command and then `other`. The exit code will be the exit code of `other`.*/
|
||||
def ## (other: ProcessBuilder): ProcessBuilder
|
||||
/** Reads the given file into the input stream of this process. */
|
||||
def #< (f: File): ProcessBuilder
|
||||
/** Reads the given URL into the input stream of this process. */
|
||||
def #< (f: URL): ProcessBuilder
|
||||
/** Writes the output stream of this process to the given file. */
|
||||
def #> (f: File): ProcessBuilder
|
||||
/** Appends the output stream of this process to the given file. */
|
||||
def #>> (f: File): ProcessBuilder
|
||||
|
||||
def canPipeTo: Boolean
|
||||
}
|
||||
/** Each method will be called in a separate thread.*/
|
||||
final class ProcessIO(val writeInput: OutputStream => Unit, val processOutput: InputStream => Unit, val processError: InputStream => Unit) extends NotNull
|
||||
{
|
||||
def withOutput(process: InputStream => Unit): ProcessIO = new ProcessIO(writeInput, process, processError)
|
||||
def withError(process: InputStream => Unit): ProcessIO = new ProcessIO(writeInput, processOutput, process)
|
||||
def withInput(write: OutputStream => Unit): ProcessIO = new ProcessIO(write, processOutput, processError)
|
||||
}
|
||||
|
|
@ -0,0 +1,462 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah, David MacIver
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import scala.collection._
|
||||
import FileUtilities._
|
||||
import Project._
|
||||
|
||||
trait Project extends TaskManager with Dag[Project] with BasicEnvironment
|
||||
{
|
||||
/** The logger for this project definition. */
|
||||
final val log: Logger = logImpl
|
||||
protected def logImpl: Logger = new BufferedLogger(new ConsoleLogger)
|
||||
|
||||
trait ActionOption extends NotNull
|
||||
|
||||
/** Basic project information. */
|
||||
def info: ProjectInfo
|
||||
/** The project name. */
|
||||
final def name: String = projectName.value
|
||||
/** The project version. */
|
||||
final def version: Version = projectVersion.value
|
||||
/** The project organization. */
|
||||
final def organization: String = projectOrganization.value
|
||||
/** True if the project should cater to a quick throwaway project setup.*/
|
||||
def scratch = projectScratch.value
|
||||
|
||||
final type ManagerType = Project
|
||||
final type ManagedTask = Project#Task
|
||||
/** The tasks declared on this project. */
|
||||
def tasks: Map[String, Task]
|
||||
/** The task methods declared on this project */
|
||||
def methods: Map[String, MethodTask]
|
||||
/** The names of all available tasks that may be called through `act`. These include
|
||||
* the names of the Tasks in `tasks` and those of all dependencies.*/
|
||||
def taskNames: Iterable[String] = deepTasks.keys.toList
|
||||
/** The names of all available method tasks that may be called through `call`. These
|
||||
* only include the names of the MethodTasks in `methods` and not those of dependencies.*/
|
||||
def methodNames: Iterable[String] = methods.keys.toList
|
||||
/** A description of all available method tasks in this project, but not of dependencies. */
|
||||
def methodList: String = descriptionList(methods)
|
||||
/** A description of all available tasks in this project and all dependencies. If there
|
||||
* are different tasks with the same name, only one will be included. */
|
||||
def taskList: String = descriptionList(deepTasks)
|
||||
|
||||
final def taskName(task: Task) = tasks.find( _._2 eq task ).map(_._1).getOrElse(UnnamedName)
|
||||
/** A description of all available tasks in this project and all dependencies and all
|
||||
* available method tasks in this project, but not of dependencies. If there
|
||||
* are different tasks or methods with the same name, only one will be included. */
|
||||
def taskAndMethodList: String = descriptionList(tasksAndMethods)
|
||||
/** The actions and methods declared on this project. */
|
||||
final def tasksAndMethods: Map[String, Described] =
|
||||
immutable.TreeMap.empty[String, Described] ++ methods ++ tasks
|
||||
private def descriptionList(described: Map[String, Described]): String =
|
||||
{
|
||||
val buffer = new StringBuilder
|
||||
for((name, d) <- described)
|
||||
buffer.append("\t" + name + d.description.map(x => ": " + x).getOrElse("") + "\n")
|
||||
buffer.toString
|
||||
}
|
||||
/** Combines the method task maps of this project and all dependencies.*/
|
||||
private[sbt] def deepMethods: Map[String, Project#MethodTask] = deep(_.methods)
|
||||
/** Combines the task maps of this project and all dependencies.*/
|
||||
private[sbt] def deepTasks: Map[String, Project#Task] = deep(_.tasks)
|
||||
private def deep[T](p: Project => Map[String, T]): Map[String, T] =
|
||||
{
|
||||
var tasks: immutable.SortedMap[String,T] = new immutable.TreeMap[String, T]
|
||||
for(dependentProject <- topologicalSort)
|
||||
tasks ++= p(dependentProject).elements
|
||||
tasks
|
||||
}
|
||||
/** A map of names to projects for all subprojects of this project. These are typically explicitly
|
||||
* specified for the project and are different from those specified in the project constructor. The
|
||||
* main use within sbt is in ParentProject.*/
|
||||
def subProjects: Map[String, Project] = immutable.Map.empty
|
||||
/** The name of this project and the names of all subprojects/dependencies, transitively.*/
|
||||
def projectNames: Iterable[String] =
|
||||
{
|
||||
val names = new mutable.HashSet[String]
|
||||
names ++= subProjects.keys
|
||||
for(dependentProject <- topologicalSort)
|
||||
names ++= dependentProject.tasks.keys
|
||||
names.toList
|
||||
}
|
||||
|
||||
def call(name: String, parameters: Array[String]): Option[String] =
|
||||
{
|
||||
methods.get(name) match
|
||||
{
|
||||
case Some(method) =>run(method(parameters), name)
|
||||
case None => Some("Method '" + name + "' does not exist.")
|
||||
}
|
||||
}
|
||||
private def run(task: Project#Task, taskName: String): Option[String] =
|
||||
impl.RunTask(task, taskName, parallelExecution) match
|
||||
{
|
||||
case Nil => None
|
||||
case x => Some(Set(x: _*).mkString("\n"))
|
||||
}
|
||||
|
||||
/** Executes the task with the given name. This involves executing the task for all
|
||||
* project dependencies (transitive) and then for this project. Not every dependency
|
||||
* must define a task with the given name. If this project and all dependencies
|
||||
* do not define a task with the given name, an error is generated indicating this.*/
|
||||
def act(name: String): Option[String] =
|
||||
{
|
||||
val ordered = topologicalSort
|
||||
val definedTasks = ordered.flatMap(_.tasks.get(name).toList)
|
||||
def virtualTask(name: String): Task = new Task(None, definedTasks.filter(!_.interactive), false, None)
|
||||
|
||||
if(definedTasks.isEmpty)
|
||||
Some("Action '" + name + "' does not exist.")
|
||||
else
|
||||
{
|
||||
tasks.get(name) match
|
||||
{
|
||||
case None =>
|
||||
val virtual = virtualTask(name)
|
||||
if(virtual.dependencies.size == definedTasks.size)
|
||||
run(virtual, name)
|
||||
else
|
||||
{
|
||||
Some("Cannot run interactive action '" + name +
|
||||
"' defined on multiple subprojects (change to the desired project with 'project <name>').")
|
||||
}
|
||||
case Some(task) => run(task, name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Logs the list of projects at the debug level.*/
|
||||
private def showBuildOrder(order: Iterable[Project])
|
||||
{
|
||||
log.debug("Project build order:")
|
||||
order.foreach(x => log.debug(" " + x.name) )
|
||||
log.debug("")
|
||||
}
|
||||
|
||||
/** Converts a String to a path relative to the project directory of this project. */
|
||||
implicit def path(component: String): Path = info.projectPath / component
|
||||
/** Converts a String to a simple name filter. * has the special meaning: zero or more of any character */
|
||||
implicit def filter(simplePattern: String): NameFilter = GlobFilter(simplePattern)
|
||||
|
||||
/** Loads the project at the given path and declares the project to have the given
|
||||
* dependencies. This method will configure the project according to the
|
||||
* project/ directory in the directory denoted by path.*/
|
||||
def project(path: Path, deps: Project*): Project = getProject(Project.loadProject(path, deps, Some(this), log), path)
|
||||
|
||||
/** Loads the project at the given path using the given name and inheriting this project's version.
|
||||
* The builder class is the default builder class, sbt.DefaultProject. The loaded project is declared
|
||||
* to have the given dependencies. Any project/build/ directory for the project is ignored.*/
|
||||
def project(path: Path, name: String, deps: Project*): Project = project(path, name, Project.DefaultBuilderClass, deps: _*)
|
||||
|
||||
/** Loads the project at the given path using the given name and inheriting it's version from this project.
|
||||
* The Project implementation used is given by builderClass. The dependencies are declared to be
|
||||
* deps. Any project/build/ directory for the project is ignored.*/
|
||||
def project[P <: Project](path: Path, name: String, builderClass: Class[P], deps: Project*): P =
|
||||
{
|
||||
require(builderClass != this.getClass, "Cannot recursively construct projects of same type: " + builderClass.getName)
|
||||
project(path, name, info => Project.constructProject(info, builderClass), deps: _*)
|
||||
}
|
||||
/** Loads the project at the given path using the given name and inheriting it's version from this project.
|
||||
* The construct function is used to obtain the Project instance. Any project/build/ directory for the project
|
||||
* is ignored. The project is declared to have the dependencies given by deps.*/
|
||||
def project[P <: Project](path: Path, name: String, construct: ProjectInfo => P, deps: Project*): P =
|
||||
initialize(construct(ProjectInfo(path.asFile, deps, Some(this))), Some(new SetupInfo(name, None, None, false)), log)
|
||||
|
||||
/** Initializes the project directories when a user has requested that sbt create a new project.*/
|
||||
def initializeDirectories() {}
|
||||
/** True if projects should be run in parallel, false if they should run sequentially.
|
||||
* This only has an effect for multi-projects. If this project has a parent, this value is
|
||||
* inherited from that parent project.*/
|
||||
def parallelExecution: Boolean =
|
||||
info.parent match
|
||||
{
|
||||
case Some(parent) => parent.parallelExecution
|
||||
case None => false
|
||||
}
|
||||
|
||||
/** True if a project and its dependencies should be checked to ensure that their
|
||||
* output directories are not the same, false if they should not be checked. */
|
||||
def shouldCheckOutputDirectories = true
|
||||
|
||||
/** The list of directories to which this project writes. This is used to verify that multiple
|
||||
* projects have not been defined with the same output directories. */
|
||||
def outputDirectories: Iterable[Path] = outputRootPath :: Nil
|
||||
def rootProject = Project.rootProject(this)
|
||||
/** The path to the file that provides persistence for properties.*/
|
||||
final def envBackingPath = info.builderPath / Project.DefaultEnvBackingName
|
||||
/** The path to the file that provides persistence for history. */
|
||||
def historyPath: Option[Path] = Some(outputRootPath / ".history")
|
||||
def outputPath = crossPath(outputRootPath)
|
||||
def outputRootPath = outputDirectoryName
|
||||
def outputDirectoryName = DefaultOutputDirectoryName
|
||||
|
||||
private def getProject(result: LoadResult, path: Path): Project =
|
||||
result match
|
||||
{
|
||||
case LoadSetupDeclined => Predef.error("No project exists at path " + path)
|
||||
case lse: LoadSetupError => Predef.error("Error setting up new project at path " + Path + " : " + lse.message)
|
||||
case err: LoadError => Predef.error("Error loading project at path " + path + " : " + err.message)
|
||||
case success: LoadSuccess => success.project
|
||||
}
|
||||
|
||||
/** The property for the project's version. */
|
||||
final val projectVersion = property[Version]
|
||||
/** The property for the project's name. */
|
||||
final val projectName = propertyLocalF[String](NonEmptyStringFormat)
|
||||
/** The property for the project's organization. Defaults to the parent project's organization or the project name if there is no parent. */
|
||||
final val projectOrganization = propertyOptional[String](normalizedName, true)
|
||||
/** The property that defines the version of Scala to build this project with by default. This property is only
|
||||
* ready by `sbt` on startup and reboot. When cross-building, this value may be different from the actual
|
||||
* version of Scala being used to build the project. ScalaVersion.current and ScalaVersion.cross should be used
|
||||
* to read the version of Scala building the project. This should only be used to change the version of Scala used
|
||||
* for normal development (not cross-building)*/
|
||||
final val scalaVersion = propertyOptional[String]("")
|
||||
final val sbtVersion = propertyOptional[String]("")
|
||||
final val projectInitialize = propertyOptional[Boolean](false)
|
||||
final val projectScratch = propertyOptional[Boolean](false)
|
||||
|
||||
/** If this project is cross-building, returns `base` with an additional path component containing the scala version.
|
||||
* Otherwise, this returns `base`.
|
||||
* By default, cross-building is enabled when a project is loaded by the loader and crossScalaVersions is not empty.*/
|
||||
def crossPath(base: Path) = ScalaVersion.withCross(disableCrossPaths)(base / ScalaVersion.crossString(_), base)
|
||||
/** If modifying paths for cross-building is enabled, this returns ScalaVersion.currentString.
|
||||
* Otherwise, this returns the empty string. */
|
||||
def crossScalaVersionString: String = if(disableCrossPaths) "" else ScalaVersion.currentString
|
||||
|
||||
/** True if crossPath should be the identity function.*/
|
||||
protected def disableCrossPaths = crossScalaVersions.isEmpty
|
||||
/** By default, this is empty and cross-building is disabled. Overriding this to a Set of Scala versions
|
||||
* will enable cross-building against those versions.*/
|
||||
def crossScalaVersions = scala.collection.immutable.Set.empty[String]
|
||||
/** A `PathFinder` that determines the files watched when an action is run with a preceeding ~ when this is the current
|
||||
* project. This project does not need to include the watched paths for projects that this project depends on.*/
|
||||
def watchPaths: PathFinder = Path.emptyPathFinder
|
||||
|
||||
protected final override def parentEnvironment = info.parent
|
||||
|
||||
// .* included because svn doesn't mark .svn hidden
|
||||
def defaultExcludes: FileFilter = (".*" - ".") || HiddenFileFilter
|
||||
/** Short for parent.descendentsExcept(include, defaultExcludes)*/
|
||||
def descendents(parent: PathFinder, include: FileFilter) = parent.descendentsExcept(include, defaultExcludes)
|
||||
override def toString = "Project " + projectName.get.getOrElse("at " + environmentLabel)
|
||||
|
||||
def normalizedName = StringUtilities.normalize(name)
|
||||
}
|
||||
private[sbt] sealed trait LoadResult extends NotNull
|
||||
private[sbt] final class LoadSuccess(val project: Project) extends LoadResult
|
||||
private[sbt] final class LoadError(val message: String) extends LoadResult
|
||||
private[sbt] final object LoadSetupDeclined extends LoadResult
|
||||
private[sbt] final class LoadSetupError(val message: String) extends LoadResult
|
||||
|
||||
object Project
|
||||
{
|
||||
val UnnamedName = "<anonymous>"
|
||||
val BootDirectoryName = "boot"
|
||||
val DefaultOutputDirectoryName = "target"
|
||||
val DefaultEnvBackingName = "build.properties"
|
||||
val DefaultBuilderClassName = "sbt.DefaultProject"
|
||||
val DefaultBuilderClass = Class.forName(DefaultBuilderClassName).asSubclass(classOf[Project])
|
||||
|
||||
/** The name of the directory for project definitions.*/
|
||||
val BuilderProjectDirectoryName = "build"
|
||||
/** The name of the directory for plugin definitions.*/
|
||||
val PluginProjectDirectoryName = "plugins"
|
||||
/** The name of the class that all projects must inherit from.*/
|
||||
val ProjectClassName = classOf[Project].getName
|
||||
|
||||
/** The logger that should be used before the root project definition is loaded.*/
|
||||
private[sbt] def bootLogger =
|
||||
{
|
||||
val log = new ConsoleLogger
|
||||
log.setLevel(Level.Debug)
|
||||
log.enableTrace(true)
|
||||
log
|
||||
}
|
||||
|
||||
private[sbt] def booted = java.lang.Boolean.getBoolean("sbt.boot")
|
||||
|
||||
/** Loads the project in the current working directory.*/
|
||||
private[sbt] def loadProject: LoadResult = loadProject(bootLogger)
|
||||
/** Loads the project in the current working directory.*/
|
||||
private[sbt] def loadProject(log: Logger): LoadResult = checkOutputDirectories(loadProject(new File("."), Nil, None, log))
|
||||
/** Loads the project in the directory given by 'path' and with the given dependencies.*/
|
||||
private[sbt] def loadProject(path: Path, deps: Iterable[Project], parent: Option[Project], log: Logger): LoadResult =
|
||||
loadProject(path.asFile, deps, parent, log)
|
||||
/** Loads the project in the directory given by 'projectDirectory' and with the given dependencies.*/
|
||||
private[sbt] def loadProject(projectDirectory: File, deps: Iterable[Project], parent: Option[Project], log: Logger): LoadResult =
|
||||
{
|
||||
val info = ProjectInfo(projectDirectory, deps, parent)
|
||||
ProjectInfo.setup(info, log) match
|
||||
{
|
||||
case err: SetupError => new LoadSetupError(err.message)
|
||||
case SetupDeclined => LoadSetupDeclined
|
||||
case AlreadySetup => loadProject(info, None, log)
|
||||
case setup: SetupInfo => loadProject(info, Some(setup), log)
|
||||
}
|
||||
}
|
||||
private def loadProject(info: ProjectInfo, setupInfo: Option[SetupInfo], log: Logger): LoadResult =
|
||||
{
|
||||
try
|
||||
{
|
||||
val oldLevel = log.getLevel
|
||||
log.setLevel(Level.Warn)
|
||||
val result =
|
||||
for(builderClass <- getProjectDefinition(info, log).right) yield
|
||||
initialize(constructProject(info, builderClass), setupInfo, log)
|
||||
log.setLevel(oldLevel)
|
||||
result.fold(new LoadError(_), new LoadSuccess(_))
|
||||
}
|
||||
catch
|
||||
{
|
||||
case ite: java.lang.reflect.InvocationTargetException =>
|
||||
{
|
||||
val cause =
|
||||
if(ite.getCause == null) ite
|
||||
else ite.getCause
|
||||
errorLoadingProject(cause, log)
|
||||
}
|
||||
case nme: NoSuchMethodException => new LoadError("Constructor with one argument of type sbt.ProjectInfo required for project definition.")
|
||||
case e: Exception => errorLoadingProject(e, log)
|
||||
}
|
||||
}
|
||||
/** Logs the stack trace and returns an error message in Left.*/
|
||||
private def errorLoadingProject(e: Throwable, log: Logger) =
|
||||
{
|
||||
log.trace(e)
|
||||
new LoadError("Error loading project: " + e.toString)
|
||||
}
|
||||
/** Loads the project for the given `info` and represented by an instance of 'builderClass'.*/
|
||||
private[sbt] def constructProject[P <: Project](info: ProjectInfo, builderClass: Class[P]): P =
|
||||
builderClass.getConstructor(classOf[ProjectInfo]).newInstance(info)
|
||||
/** Checks the project's dependencies, initializes its environment, and possibly its directories.*/
|
||||
private def initialize[P <: Project](p: P, setupInfo: Option[SetupInfo], log: Logger): P =
|
||||
{
|
||||
setupInfo match
|
||||
{
|
||||
case Some(setup) =>
|
||||
{
|
||||
p.projectName() = setup.name
|
||||
for(v <- setup.version)
|
||||
p.projectVersion() = v
|
||||
for(org <- setup.organization)
|
||||
p.projectOrganization() = org
|
||||
if(!setup.initializeDirectories)
|
||||
p.setEnvironmentModified(false)
|
||||
for(errorMessage <- p.saveEnvironment())
|
||||
log.error(errorMessage)
|
||||
if(setup.initializeDirectories)
|
||||
p.initializeDirectories()
|
||||
}
|
||||
case None =>
|
||||
if(p.projectInitialize.value)
|
||||
{
|
||||
p.initializeDirectories()
|
||||
p.projectInitialize() = false
|
||||
for(errorMessage <- p.saveEnvironment())
|
||||
log.error(errorMessage)
|
||||
}
|
||||
}
|
||||
val useName = p.projectName.get.getOrElse("at " + p.info.projectDirectory.getAbsolutePath)
|
||||
checkDependencies(useName, p.info.dependencies, log)
|
||||
p
|
||||
}
|
||||
/** Compiles the project definition classes and returns the project definition class name
|
||||
* and the class loader that should be used to load the definition. */
|
||||
private def getProjectDefinition(info: ProjectInfo, buildLog: Logger): Either[String, Class[P] forSome { type P <: Project }] =
|
||||
{
|
||||
val builderProjectPath = info.builderPath / BuilderProjectDirectoryName
|
||||
if(builderProjectPath.asFile.isDirectory)
|
||||
{
|
||||
val pluginProjectPath = info.builderPath / PluginProjectDirectoryName
|
||||
val builderProject = new BuilderProject(ProjectInfo(builderProjectPath.asFile, Nil, None), pluginProjectPath, buildLog)
|
||||
builderProject.compile.run.toLeft(()).right.flatMap { ignore =>
|
||||
builderProject.projectDefinition.right.map {
|
||||
case Some(definition) => getProjectClass[Project](definition, builderProject.projectClasspath)
|
||||
case None => DefaultBuilderClass
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
Right(DefaultBuilderClass)
|
||||
}
|
||||
/** Verifies that the given list of project dependencies contains no nulls. The
|
||||
* String argument should be the project name with the dependencies.*/
|
||||
private def checkDependencies(forProject: String, deps: Iterable[Project], log: Logger)
|
||||
{
|
||||
for(nullDep <- deps.find(_ == null))
|
||||
{
|
||||
log.error("Project " + forProject + " had a null dependency. This is probably an initialization problem and might be due to a circular dependency.")
|
||||
throw new RuntimeException("Null dependency in project " + forProject)
|
||||
}
|
||||
}
|
||||
/** Verifies that output directories of the given project and all of its dependencies are
|
||||
* all different. No verification is done if the project overrides
|
||||
* 'shouldCheckOutputDirectories' to be false. The 'Project.outputDirectories' method is
|
||||
* used to determine a project's output directories. */
|
||||
private def checkOutputDirectories(result: LoadResult): LoadResult =
|
||||
result match
|
||||
{
|
||||
case success: LoadSuccess =>
|
||||
if(success.project.shouldCheckOutputDirectories)
|
||||
checkOutputDirectoriesImpl(success.project)
|
||||
else
|
||||
success
|
||||
case x => x
|
||||
}
|
||||
/** Verifies that output directories of the given project and all of its dependencies are
|
||||
* all different. The 'Project.outputDirectories' method is used to determine a project's
|
||||
* output directories. */
|
||||
private def checkOutputDirectoriesImpl(project: Project): LoadResult =
|
||||
{
|
||||
val projects = project.topologicalSort
|
||||
import scala.collection.mutable.{HashMap, HashSet, Set}
|
||||
val outputDirectories = new HashMap[Path, Set[Project]]
|
||||
for(p <- projects; path <- p.outputDirectories)
|
||||
outputDirectories.getOrElseUpdate(path, new HashSet[Project]) += p
|
||||
val shared = outputDirectories.filter(_._2.size > 1)
|
||||
if(shared.isEmpty)
|
||||
new LoadSuccess(project)
|
||||
else
|
||||
{
|
||||
val sharedString =
|
||||
{
|
||||
val s =
|
||||
for((path, projectsSharingPath) <- shared) yield
|
||||
projectsSharingPath.map(_.name).mkString(", ") + " share " + path
|
||||
s.mkString("\n\t")
|
||||
}
|
||||
new LoadError("The same directory is used for output for multiple projects:\n\t" + sharedString +
|
||||
"\n (If this is intentional, use 'override def shouldCheckOutputDirectories = false' in your project definition.)")
|
||||
}
|
||||
}
|
||||
import scala.reflect.Manifest
|
||||
private[sbt] def getProjectClass[P <: Project](name: String, classpath: PathFinder)(implicit mf: Manifest[P]): Class[P] =
|
||||
{
|
||||
val loader =ClasspathUtilities.toLoader(classpath)
|
||||
val builderClass = Class.forName(name, false, loader)
|
||||
val projectClass = mf.erasure
|
||||
require(projectClass.isAssignableFrom(builderClass), "Builder class '" + builderClass + "' does not extend " + projectClass.getName + ".")
|
||||
builderClass.asSubclass(projectClass).asInstanceOf[Class[P]]
|
||||
}
|
||||
|
||||
/** Writes the project name and a separator to the project's log at the info level.*/
|
||||
def showProjectHeader(project: Project)
|
||||
{
|
||||
val projectHeader = "Project " + project.name
|
||||
project.log.info("")
|
||||
project.log.info(projectHeader)
|
||||
project.log.info("=" * projectHeader.length)
|
||||
}
|
||||
|
||||
def rootProject(p: Project): Project =
|
||||
p.info.parent match
|
||||
{
|
||||
case Some(parent) => rootProject(parent)
|
||||
case None => p
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import FileUtilities._
|
||||
|
||||
final case class ProjectInfo(projectDirectory: File, dependencies: Iterable[Project], parent: Option[Project]) extends NotNull
|
||||
{
|
||||
val projectPath = new ProjectDirectory(projectDirectory)
|
||||
val builderPath = projectPath / ProjectInfo.MetadataDirectoryName
|
||||
def bootPath = builderPath / Project.BootDirectoryName
|
||||
def builderProjectPath = builderPath / Project.BuilderProjectDirectoryName
|
||||
def builderProjectOutputPath = builderProjectPath / Project.DefaultOutputDirectoryName
|
||||
def pluginsPath = builderPath / Project.PluginProjectDirectoryName
|
||||
def pluginsOutputPath = pluginsPath / Project.DefaultOutputDirectoryName
|
||||
def pluginsManagedSourcePath = pluginsPath / BasicDependencyPaths.DefaultManagedSourceDirectoryName
|
||||
def pluginsManagedDependencyPath = pluginsPath / BasicDependencyPaths.DefaultManagedDirectoryName
|
||||
}
|
||||
|
||||
private[sbt] sealed trait SetupResult extends NotNull
|
||||
private[sbt] final object SetupDeclined extends SetupResult
|
||||
private[sbt] final class SetupError(val message: String) extends SetupResult
|
||||
private[sbt] final object AlreadySetup extends SetupResult
|
||||
private[sbt] final class SetupInfo(val name: String, val version: Option[Version], val organization: Option[String], val initializeDirectories: Boolean) extends SetupResult
|
||||
|
||||
object ProjectInfo
|
||||
{
|
||||
val MetadataDirectoryName = "project"
|
||||
private val DefaultOrganization = "empty"
|
||||
|
||||
def setup(info: ProjectInfo, log: Logger): SetupResult =
|
||||
{
|
||||
val builderDirectory = info.builderPath.asFile
|
||||
if(builderDirectory.exists)
|
||||
{
|
||||
if(builderDirectory.isDirectory)
|
||||
AlreadySetup
|
||||
else
|
||||
new SetupError("'" + builderDirectory.getAbsolutePath + "' is not a directory.")
|
||||
}
|
||||
else
|
||||
setupProject(info.projectDirectory, log)
|
||||
}
|
||||
private def setupProject(projectDirectory: File, log: Logger): SetupResult =
|
||||
{
|
||||
if(confirmPrompt("No project found. Create new project?", false))
|
||||
{
|
||||
val name = trim(SimpleReader.readLine("Project Name: "))
|
||||
if(name.isEmpty)
|
||||
new SetupError("Project not created: no name specified.")
|
||||
else
|
||||
{
|
||||
val organization =
|
||||
{
|
||||
val org = trim(SimpleReader.readLine("Organization [" + DefaultOrganization + "]: "))
|
||||
if(org.isEmpty)
|
||||
DefaultOrganization
|
||||
else
|
||||
org
|
||||
}
|
||||
readVersion(projectDirectory, log) match
|
||||
{
|
||||
case None => new SetupError("Project not created: no version specified.")
|
||||
case Some(version) =>
|
||||
if(verifyCreateProject(name, version, organization))
|
||||
new SetupInfo(name, Some(version), Some(organization), true)
|
||||
else
|
||||
SetupDeclined
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
SetupDeclined
|
||||
}
|
||||
private def verifyCreateProject(name: String, version: Version, organization: String): Boolean =
|
||||
confirmPrompt("Create new project " + name + " " + version + " with organization " + organization +" ?", true)
|
||||
|
||||
private def confirmPrompt(question: String, defaultYes: Boolean) =
|
||||
{
|
||||
val choices = if(defaultYes) " (Y/n) " else " (y/N) "
|
||||
val answer = trim(SimpleReader.readLine(question + choices))
|
||||
val yes = "y" :: "yes" :: (if(defaultYes) List("") else Nil)
|
||||
yes.contains(answer.toLowerCase)
|
||||
}
|
||||
|
||||
private def readVersion(projectDirectory: File, log: Logger): Option[Version] =
|
||||
{
|
||||
val version = trim(SimpleReader.readLine("Version: "))
|
||||
if(version.isEmpty)
|
||||
None
|
||||
else
|
||||
{
|
||||
Version.fromString(version) match
|
||||
{
|
||||
case Left(errorMessage) =>
|
||||
{
|
||||
log.error("Invalid version: " + errorMessage)
|
||||
readVersion(projectDirectory, log)
|
||||
}
|
||||
case Right(v) => Some(v)
|
||||
}
|
||||
}
|
||||
}
|
||||
private def trim(s: Option[String]) = s.getOrElse("")
|
||||
}
|
||||
|
|
@ -0,0 +1,300 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
trait PackagePaths extends NotNull
|
||||
{
|
||||
def jarPath: Path
|
||||
def packageTestJar: Path
|
||||
def packageDocsJar: Path
|
||||
def packageSrcJar: Path
|
||||
def packageTestSrcJar: Path
|
||||
def packageProjectZip: Path
|
||||
}
|
||||
/** These are the paths required by BasicScalaProject.*/
|
||||
trait ScalaPaths extends PackagePaths
|
||||
{
|
||||
/** A PathFinder that selects all main sources.*/
|
||||
def mainSources: PathFinder
|
||||
/** A PathFinder that selects all test sources.*/
|
||||
def testSources: PathFinder
|
||||
/** A PathFinder that selects all main resources.*/
|
||||
def mainResources: PathFinder
|
||||
/** A PathFinder that selects all test resources. */
|
||||
def testResources: PathFinder
|
||||
|
||||
def mainResourceClasspath: PathFinder
|
||||
def testResourceClasspath: PathFinder
|
||||
|
||||
def mainCompilePath: Path
|
||||
def testCompilePath: Path
|
||||
def mainAnalysisPath: Path
|
||||
def testAnalysisPath: Path
|
||||
def mainDocPath: Path
|
||||
def testDocPath: Path
|
||||
def graphPath: Path
|
||||
|
||||
/** A PathFinder that selects all the classes compiled from the main sources.*/
|
||||
def mainClasses: PathFinder
|
||||
/** A PathFinder that selects all the classes compiled from the test sources.*/
|
||||
def testClasses: PathFinder
|
||||
|
||||
/** Declares all paths to be packaged by the package action.*/
|
||||
def packagePaths: PathFinder
|
||||
/** Declares all paths to be packaged by the package-test action.*/
|
||||
def packageTestPaths: PathFinder
|
||||
/** Declares all sources to be packaged by the package-src action.*/
|
||||
def packageSourcePaths: PathFinder
|
||||
/** Declares all sources to be packaged by the package-test-src action.*/
|
||||
def packageTestSourcePaths: PathFinder
|
||||
/** Declares all paths to be packaged by the package-project action.*/
|
||||
def packageProjectPaths: PathFinder
|
||||
|
||||
/** These are the directories that are created when a user makes a new project from sbt.*/
|
||||
protected def directoriesToCreate: List[Path]
|
||||
/** The directories to which a project writes are listed here and is used
|
||||
* to check a project and its dependencies for collisions.*/
|
||||
def outputDirectories: Iterable[Path]
|
||||
|
||||
def artifactBaseName: String
|
||||
}
|
||||
|
||||
trait BasicScalaPaths extends Project with ScalaPaths
|
||||
{
|
||||
def mainSourceRoots: PathFinder
|
||||
def testSourceRoots: PathFinder
|
||||
def mainResourcesPath: PathFinder
|
||||
def testResourcesPath: PathFinder
|
||||
def managedDependencyRootPath: Path
|
||||
def dependencyPath: Path
|
||||
|
||||
protected def sources(base: PathFinder) = descendents(base, sourceExtensions)
|
||||
protected def sourceExtensions = "*.scala" | "*.java"
|
||||
|
||||
def mainSources =
|
||||
{
|
||||
val normal = sources(mainSourceRoots)
|
||||
if(scratch)
|
||||
normal +++ (info.projectPath * sourceExtensions)
|
||||
else
|
||||
normal
|
||||
}
|
||||
def testSources = sources(testSourceRoots)
|
||||
|
||||
def mainResourceClasspath = mainResourcesPath
|
||||
def testResourceClasspath = testResourcesPath
|
||||
def mainResources = descendents(mainResourcesPath ##, "*")
|
||||
def testResources = descendents(testResourcesPath ##, "*")
|
||||
|
||||
def mainClasses = (mainCompilePath ##) ** "*.class"
|
||||
def testClasses = (testCompilePath ##) ** "*.class"
|
||||
|
||||
def packagePaths = mainClasses +++ mainResources
|
||||
def packageTestPaths = testClasses +++ testResources
|
||||
def packageSourcePaths = mainSources +++ mainResources
|
||||
def packageTestSourcePaths = testSources +++ testResources
|
||||
def packageProjectPaths = descendents( (info.projectPath ##), "*") --- (packageProjectExcludes ** "*")
|
||||
protected def packageProjectExcludes: PathFinder =
|
||||
outputRootPath +++ managedDependencyRootPath +++
|
||||
info.bootPath +++ info.builderProjectOutputPath +++
|
||||
info.pluginsOutputPath +++ info.pluginsManagedSourcePath +++ info.pluginsManagedDependencyPath
|
||||
|
||||
override def outputDirectories = outputRootPath :: managedDependencyRootPath :: Nil
|
||||
}
|
||||
|
||||
@deprecated trait BasicProjectPaths extends MavenStyleScalaPaths
|
||||
trait MavenStyleScalaPaths extends BasicScalaPaths with BasicPackagePaths
|
||||
{
|
||||
import BasicProjectPaths._
|
||||
|
||||
def outputPath: Path
|
||||
|
||||
def sourceDirectoryName = DefaultSourceDirectoryName
|
||||
def mainDirectoryName = DefaultMainDirectoryName
|
||||
def scalaDirectoryName = DefaultScalaDirectoryName
|
||||
def javaDirectoryName = DefaultJavaDirectoryName
|
||||
def resourcesDirectoryName = DefaultResourcesDirectoryName
|
||||
def testDirectoryName = DefaultTestDirectoryName
|
||||
def mainCompileDirectoryName = DefaultMainCompileDirectoryName
|
||||
def testCompileDirectoryName = DefaultTestCompileDirectoryName
|
||||
def docDirectoryName = DefaultDocDirectoryName
|
||||
def apiDirectoryName = DefaultAPIDirectoryName
|
||||
def graphDirectoryName = DefaultGraphDirectoryName
|
||||
def mainAnalysisDirectoryName = DefaultMainAnalysisDirectoryName
|
||||
def testAnalysisDirectoryName = DefaultTestAnalysisDirectoryName
|
||||
|
||||
def sourcePath = path(sourceDirectoryName)
|
||||
|
||||
def mainSourcePath = sourcePath / mainDirectoryName
|
||||
def mainScalaSourcePath = mainSourcePath / scalaDirectoryName
|
||||
def mainJavaSourcePath = mainSourcePath / javaDirectoryName
|
||||
def mainResourcesPath = mainSourcePath / resourcesDirectoryName
|
||||
def mainDocPath = docPath / mainDirectoryName / apiDirectoryName
|
||||
def mainCompilePath = outputPath / mainCompileDirectoryName
|
||||
def mainAnalysisPath = outputPath / mainAnalysisDirectoryName
|
||||
|
||||
def testSourcePath = sourcePath / testDirectoryName
|
||||
def testJavaSourcePath = testSourcePath / javaDirectoryName
|
||||
def testScalaSourcePath = testSourcePath / scalaDirectoryName
|
||||
def testResourcesPath = testSourcePath / resourcesDirectoryName
|
||||
def testDocPath = docPath / testDirectoryName / apiDirectoryName
|
||||
def testCompilePath = outputPath / testCompileDirectoryName
|
||||
def testAnalysisPath = outputPath / testAnalysisDirectoryName
|
||||
|
||||
def docPath = outputPath / docDirectoryName
|
||||
def graphPath = outputPath / graphDirectoryName
|
||||
|
||||
/** These are the directories that are created when a user makes a new project from sbt.*/
|
||||
protected def directoriesToCreate: List[Path] =
|
||||
dependencyPath ::
|
||||
mainScalaSourcePath ::
|
||||
mainResourcesPath ::
|
||||
testScalaSourcePath ::
|
||||
testResourcesPath ::
|
||||
Nil
|
||||
|
||||
def mainSourceRoots = mainJavaSourcePath +++ mainScalaSourcePath
|
||||
def testSourceRoots = testJavaSourcePath +++ testScalaSourcePath
|
||||
}
|
||||
|
||||
trait BasicPackagePaths extends ScalaPaths with PackagePaths
|
||||
{
|
||||
def outputPath: Path
|
||||
|
||||
def defaultJarBaseName: String = artifactBaseName
|
||||
def defaultJarName = defaultJarBaseName + ".jar"
|
||||
def jarPath = outputPath / defaultJarName
|
||||
def packageTestJar = defaultJarPath("-test.jar")
|
||||
def packageDocsJar = defaultJarPath("-docs.jar")
|
||||
def packageSrcJar= defaultJarPath("-src.jar")
|
||||
def packageTestSrcJar = defaultJarPath("-test-src.jar")
|
||||
def packageProjectZip = defaultJarPath("-project.zip")
|
||||
def defaultJarPath(extension: String) = outputPath / (artifactBaseName + extension)
|
||||
}
|
||||
|
||||
object BasicProjectPaths
|
||||
{
|
||||
val DefaultSourceDirectoryName = "src"
|
||||
val DefaultMainCompileDirectoryName = "classes"
|
||||
val DefaultTestCompileDirectoryName = "test-classes"
|
||||
val DefaultDocDirectoryName = "doc"
|
||||
val DefaultAPIDirectoryName = "api"
|
||||
val DefaultGraphDirectoryName = "graph"
|
||||
val DefaultMainAnalysisDirectoryName = "analysis"
|
||||
val DefaultTestAnalysisDirectoryName = "test-analysis"
|
||||
|
||||
val DefaultMainDirectoryName = "main"
|
||||
val DefaultScalaDirectoryName = "scala"
|
||||
val DefaultJavaDirectoryName = "java"
|
||||
val DefaultResourcesDirectoryName = "resources"
|
||||
val DefaultTestDirectoryName = "test"
|
||||
|
||||
// forwarders to new locations
|
||||
def BootDirectoryName = Project.BootDirectoryName
|
||||
def DefaultManagedDirectoryName = BasicDependencyPaths.DefaultManagedDirectoryName
|
||||
def DefaultDependencyDirectoryName = BasicDependencyPaths.DefaultDependencyDirectoryName
|
||||
}
|
||||
|
||||
trait WebScalaPaths extends ScalaPaths
|
||||
{
|
||||
def temporaryWarPath: Path
|
||||
def webappResources: PathFinder
|
||||
def jettyContextPath: String
|
||||
def warPath: Path
|
||||
}
|
||||
@deprecated trait WebProjectPaths extends MavenStyleWebScalaPaths
|
||||
trait MavenStyleWebScalaPaths extends WebScalaPaths with MavenStyleScalaPaths
|
||||
{
|
||||
import WebProjectPaths._
|
||||
def temporaryWarPath = outputPath / webappDirectoryName
|
||||
def webappPath = mainSourcePath / webappDirectoryName
|
||||
def webappDirectoryName = DefaultWebappDirectoryName
|
||||
def jettyContextPath = DefaultJettyContextPath
|
||||
def defaultWarName = defaultJarBaseName + ".war"
|
||||
def warPath = outputPath / defaultWarName
|
||||
/** Additional files to include in the web application. */
|
||||
protected def extraWebappFiles: PathFinder = Path.emptyPathFinder
|
||||
def webappResources = descendents(webappPath ##, "*") +++ extraWebappFiles
|
||||
}
|
||||
object WebProjectPaths
|
||||
{
|
||||
val DefaultWebappDirectoryName = "webapp"
|
||||
val DefaultJettyContextPath = "/"
|
||||
}
|
||||
|
||||
/** Defines default paths for a webstart project. It directly extends WebstartOptions to make
|
||||
* it easy to implement and override webstart options in the common case of one webstartTask per
|
||||
* project.*/
|
||||
trait WebstartPaths extends ScalaPaths
|
||||
{
|
||||
import WebstartPaths._
|
||||
|
||||
def outputPath: Path
|
||||
def jnlpPath: Path
|
||||
|
||||
def webstartOutputDirectory = outputPath / webstartDirectoryName
|
||||
|
||||
def jnlpFile = webstartOutputDirectory / jnlpFileName
|
||||
def webstartLibDirectory = webstartOutputDirectory / webstartLibName
|
||||
def webstartZip: Option[Path] = Some(outputPath / webstartZipName)
|
||||
def jnlpResourcesPath = jnlpPath / BasicProjectPaths.DefaultResourcesDirectoryName
|
||||
|
||||
def webstartLibName = DefaultWebstartLibName
|
||||
def webstartDirectoryName = DefaultWebstartDirectoryName
|
||||
|
||||
def webstartZipName: String
|
||||
def jnlpFileName: String
|
||||
}
|
||||
object WebstartPaths
|
||||
{
|
||||
val DefaultWebstartDirectoryName = "webstart"
|
||||
val DefaultJnlpName = "jnlp"
|
||||
val DefaultWebstartLibName = "lib"
|
||||
}
|
||||
trait MavenStyleWebstartPaths extends WebstartPaths with MavenStyleScalaPaths
|
||||
{
|
||||
import WebstartPaths._
|
||||
def jnlpPath = mainSourcePath / DefaultJnlpName
|
||||
def webstartMainJar = jarPath
|
||||
def jnlpFileName = DefaultJnlpFileName
|
||||
def webstartZipName = artifactBaseName + ".zip"
|
||||
def DefaultJnlpFileName = artifactBaseName + ".jnlp"
|
||||
}
|
||||
|
||||
trait IntegrationTestPaths extends NotNull
|
||||
{
|
||||
def integrationTestSources: PathFinder
|
||||
def integrationTestResourcesPath: Path
|
||||
|
||||
def integrationTestCompilePath: Path
|
||||
def integrationTestAnalysisPath: Path
|
||||
}
|
||||
trait BasicIntegrationTestPaths extends IntegrationTestPaths
|
||||
{
|
||||
def integrationTestScalaSourcePath: Path
|
||||
def integrationTestSources = sources(integrationTestScalaSourcePath)
|
||||
protected def sources(base: Path): PathFinder
|
||||
}
|
||||
trait MavenStyleIntegrationTestPaths extends BasicIntegrationTestPaths with MavenStyleScalaPaths
|
||||
{
|
||||
import IntegrationTestPaths._
|
||||
|
||||
def integrationTestDirectoryName = DefaultIntegrationTestDirectoryName
|
||||
def integrationTestCompileDirectoryName = DefaultIntegrationTestCompileDirectoryName
|
||||
def integrationTestAnalysisDirectoryName = DefaultIntegrationTestAnalysisDirectoryName
|
||||
|
||||
def integrationTestSourcePath = sourcePath / integrationTestDirectoryName
|
||||
def integrationTestScalaSourcePath = integrationTestSourcePath / scalaDirectoryName
|
||||
def integrationTestResourcesPath = integrationTestSourcePath / resourcesDirectoryName
|
||||
|
||||
def integrationTestCompilePath = outputPath / integrationTestCompileDirectoryName
|
||||
def integrationTestAnalysisPath = outputPath / integrationTestAnalysisDirectoryName
|
||||
}
|
||||
|
||||
object IntegrationTestPaths
|
||||
{
|
||||
val DefaultIntegrationTestDirectoryName = "it"
|
||||
val DefaultIntegrationTestCompileDirectoryName = "it-classes"
|
||||
val DefaultIntegrationTestAnalysisDirectoryName = "it-analysis"
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 David MacIver, Mark Harrah
|
||||
*/
|
||||
package sbt;
|
||||
|
||||
import scala.collection._
|
||||
|
||||
object ReflectUtilities
|
||||
{
|
||||
def transformCamelCase(name: String, separator: Char) =
|
||||
{
|
||||
val buffer = new StringBuilder
|
||||
for(char <- name)
|
||||
{
|
||||
import java.lang.Character._
|
||||
if(isUpperCase(char))
|
||||
{
|
||||
buffer += separator
|
||||
buffer += toLowerCase(char)
|
||||
}
|
||||
else
|
||||
buffer += char
|
||||
}
|
||||
buffer.toString
|
||||
}
|
||||
|
||||
def ancestry(clazz : Class[_]) : List[Class[_]] =
|
||||
if (clazz == classOf[AnyRef] || !classOf[AnyRef].isAssignableFrom(clazz)) List(clazz)
|
||||
else clazz :: ancestry(clazz.getSuperclass);
|
||||
|
||||
def fields(clazz : Class[_]) =
|
||||
mutable.OpenHashMap(ancestry(clazz).
|
||||
flatMap(_.getDeclaredFields).
|
||||
map(f => (f.getName, f)):_*)
|
||||
|
||||
def allValsC[T](self: AnyRef, clazz: Class[T]): Map[String, T] =
|
||||
{
|
||||
val mappings = new mutable.OpenHashMap[String, T]
|
||||
val correspondingFields = fields(self.getClass)
|
||||
for(method <- self.getClass.getMethods)
|
||||
{
|
||||
if(method.getParameterTypes.length == 0 && clazz.isAssignableFrom(method.getReturnType))
|
||||
{
|
||||
for(field <- correspondingFields.get(method.getName) if field.getType == method.getReturnType)
|
||||
mappings(method.getName) = method.invoke(self).asInstanceOf[T]
|
||||
}
|
||||
}
|
||||
mappings
|
||||
}
|
||||
def allVals[T](self: AnyRef)(implicit mt: scala.reflect.Manifest[T]): Map[String, T] =
|
||||
allValsC(self, mt.erasure).asInstanceOf[Map[String,T]]
|
||||
}
|
||||
|
|
@ -0,0 +1,149 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import FileUtilities._
|
||||
|
||||
object Resources
|
||||
{
|
||||
def apply(basePath: String) =
|
||||
{
|
||||
require(basePath.startsWith("/"))
|
||||
val resource = getClass.getResource(basePath)
|
||||
if(resource == null)
|
||||
throw new Exception("Resource base directory '" + basePath + "' not on classpath.")
|
||||
else
|
||||
{
|
||||
val file = new File(resource.toURI)
|
||||
if(file.exists)
|
||||
new Resources(file)
|
||||
else
|
||||
throw new Exception("Resource base directory '" + basePath + "' does not exist.")
|
||||
}
|
||||
}
|
||||
private val LoadErrorPrefix = "Error loading initial project: "
|
||||
}
|
||||
|
||||
class Resources(val baseDirectory: File)
|
||||
{
|
||||
import Resources._
|
||||
// The returned directory is not actually read-only, but it should be treated that way
|
||||
def readOnlyResourceDirectory(group: String, name: String): Either[String, File] =
|
||||
{
|
||||
val groupDirectory = new File(baseDirectory, group)
|
||||
if(groupDirectory.isDirectory)
|
||||
{
|
||||
val resourceDirectory = new File(groupDirectory, name)
|
||||
if(resourceDirectory.isDirectory)
|
||||
Right(resourceDirectory)
|
||||
else
|
||||
Left("Resource directory '" + name + "' in group '" + group + "' not found.")
|
||||
}
|
||||
else
|
||||
Left("Group '" + group + "' not found.")
|
||||
}
|
||||
def readWriteResourceDirectory[T](group: String, name: String, log: Logger)
|
||||
(withDirectory: File => Either[String, T]): Either[String, T] =
|
||||
readOnlyResourceDirectory(group, name).right flatMap(file => readWriteResourceDirectory(file, log)(withDirectory))
|
||||
def readWriteResourceDirectory[T](readOnly: File, log: Logger)
|
||||
(withDirectory: File => Either[String, T]): Either[String, T] =
|
||||
{
|
||||
require(readOnly.isDirectory)
|
||||
def readWrite(readOnly: File)(temporary: File): Either[String, T] =
|
||||
{
|
||||
val readWriteDirectory = new File(temporary, readOnly.getName)
|
||||
FileUtilities.copyDirectory(readOnly, readWriteDirectory, log).toLeft(()).right flatMap { x =>
|
||||
withDirectory(readWriteDirectory)
|
||||
}
|
||||
}
|
||||
doInTemporaryDirectory(log)(readWrite(readOnly))
|
||||
}
|
||||
|
||||
def withProject[T](projectDirectory: File, log: Logger)(f: Project => WithProjectResult[T]): Either[String, T] =
|
||||
readWriteResourceDirectory(projectDirectory, log)(withProject(log)(f))
|
||||
def withProject[T](group: String, name: String, log: Logger)(f: Project => WithProjectResult[T]): Either[String, T] =
|
||||
readWriteResourceDirectory(group, name, log)(withProject(log)(f))
|
||||
def withProject[T](log: Logger)(f: Project => WithProjectResult[T])(dir: File): Either[String, T] =
|
||||
withProject(log, None, new ReloadSuccessExpected(LoadErrorPrefix), dir )(f)
|
||||
private def withProject[T](log: Logger, previousProject: Option[Project], reload: ReloadProject, dir: File)
|
||||
(f: Project => WithProjectResult[T]): Either[String, T] =
|
||||
{
|
||||
require(previousProject.isDefined || reload != NoReload, "Previous project undefined and reload not requested.")
|
||||
val loadResult =
|
||||
if(reload == NoReload && previousProject.isDefined)
|
||||
Right(previousProject.get)
|
||||
else
|
||||
{
|
||||
val buffered = new BufferedLogger(log)
|
||||
def error(msg: String) =
|
||||
{
|
||||
buffered.playAll()
|
||||
buffered.stop()
|
||||
Left(msg)
|
||||
}
|
||||
|
||||
buffered.startRecording()
|
||||
resultToEither(Project.loadProject(dir, Nil, None, buffered)) match
|
||||
{
|
||||
case Left(msg) =>
|
||||
reload match
|
||||
{
|
||||
case ReloadErrorExpected =>
|
||||
buffered.stop()
|
||||
previousProject.toRight("Initial project load failed.")
|
||||
case s: ReloadSuccessExpected => error(s.prefixIfError + msg)
|
||||
case NoReload /* shouldn't happen */=> error(msg)
|
||||
}
|
||||
case Right(p) =>
|
||||
reload match
|
||||
{
|
||||
case ReloadErrorExpected => error("Expected project load failure, but it succeeded.")
|
||||
case _ =>
|
||||
buffered.stop()
|
||||
Right(p)
|
||||
}
|
||||
}
|
||||
}
|
||||
loadResult match
|
||||
{
|
||||
case Right(project) =>
|
||||
project.log.enableTrace(log.traceEnabled)
|
||||
project.log.setLevel(log.getLevel)
|
||||
f(project) match
|
||||
{
|
||||
case ContinueResult(newF, newReload) => withProject(log, Some(project), newReload, dir)(newF)
|
||||
case ValueResult(value) => Right(value)
|
||||
case err: ErrorResult => Left(err.message)
|
||||
}
|
||||
case Left(message) => Left(message)
|
||||
}
|
||||
}
|
||||
|
||||
def resultToEither(result: LoadResult): Either[String, Project] =
|
||||
result match
|
||||
{
|
||||
case success: LoadSuccess => Right(success.project)
|
||||
case err: LoadError => Left(err.message)
|
||||
case err: LoadSetupError => Left(err.message)
|
||||
case LoadSetupDeclined => Left("Setup declined")
|
||||
}
|
||||
}
|
||||
sealed trait ReloadProject extends NotNull
|
||||
final object ReloadErrorExpected extends ReloadProject
|
||||
final class ReloadSuccessExpected(val prefixIfError: String) extends ReloadProject
|
||||
final object NoReload extends ReloadProject
|
||||
|
||||
sealed trait WithProjectResult[+T] extends NotNull
|
||||
final case class ContinueResult[T](f: Project => WithProjectResult[T], reload: ReloadProject) extends WithProjectResult[T]
|
||||
final case class ValueResult[T](value: T) extends WithProjectResult[T]
|
||||
final class ErrorResult(val message: String) extends WithProjectResult[Nothing]
|
||||
object ContinueResult
|
||||
{
|
||||
def apply[T](f: Project => WithProjectResult[T], prefixIfError: Option[String]) =
|
||||
{
|
||||
val reload = prefixIfError match { case None => NoReload; case Some(p) => new ReloadSuccessExpected(p) }
|
||||
new ContinueResult[T](f, reload)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import scala.tools.nsc.{GenericRunnerCommand, Interpreter, InterpreterLoop, ObjectRunner, Settings}
|
||||
import scala.tools.nsc.interpreter.InteractiveReader
|
||||
import scala.tools.nsc.reporters.Reporter
|
||||
import scala.tools.nsc.util.ClassPath
|
||||
|
||||
import java.io.File
|
||||
import java.net.{URL, URLClassLoader}
|
||||
|
||||
trait ScalaRun
|
||||
{
|
||||
def console(classpath: Iterable[Path], log: Logger): Option[String]
|
||||
def run(mainClass: String, classpath: Iterable[Path], options: Seq[String], log: Logger): Option[String]
|
||||
}
|
||||
class ForkRun(config: ForkScalaRun) extends ScalaRun
|
||||
{
|
||||
def console(classpath: Iterable[Path], log: Logger): Option[String] =
|
||||
{
|
||||
error("Forking the interpreter is not implemented.")
|
||||
//val exitCode = Fork.scala(config.javaHome, config.runJVMOptions, config.scalaJars, classpathOption(classpath), config.workingDirectory, log)
|
||||
//processExitCode(exitCode, "interpreter")
|
||||
}
|
||||
def run(mainClass: String, classpath: Iterable[Path], options: Seq[String], log: Logger): Option[String] =
|
||||
{
|
||||
val scalaOptions = classpathOption(classpath) ::: mainClass :: options.toList
|
||||
val exitCode = Fork.scala(config.javaHome, config.runJVMOptions, config.scalaJars, scalaOptions, config.workingDirectory, log)
|
||||
processExitCode(exitCode, "runner")
|
||||
}
|
||||
private def classpathOption(classpath: Iterable[Path]) = "-cp" :: Path.makeString(classpath) :: Nil
|
||||
private def processExitCode(exitCode: Int, label: String) =
|
||||
{
|
||||
if(exitCode == 0)
|
||||
None
|
||||
else
|
||||
Some("Nonzero exit code returned from " + label + ": " + exitCode)
|
||||
}
|
||||
}
|
||||
|
||||
/** This module is an interface to starting the scala interpreter or runner.*/
|
||||
object Run extends ScalaRun
|
||||
{
|
||||
/** Starts an interactive scala interpreter session with the given classpath.*/
|
||||
def console(classpath: Iterable[Path], log: Logger) =
|
||||
createSettings(log)
|
||||
{
|
||||
(settings: Settings) =>
|
||||
{
|
||||
settings.classpath.value = Path.makeString(classpath)
|
||||
log.info("Starting scala interpreter...")
|
||||
log.debug(" Classpath: " + settings.classpath.value)
|
||||
log.info("")
|
||||
Control.trapUnit("Error during session: ", log)
|
||||
{
|
||||
val loop = new InterpreterLoop
|
||||
executeTrapExit(loop.main(settings), log)
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Executes the given function, trapping calls to System.exit. */
|
||||
private def executeTrapExit(f: => Unit, log: Logger): Option[String] =
|
||||
{
|
||||
val exitCode = TrapExit(f, log)
|
||||
if(exitCode == 0)
|
||||
{
|
||||
log.debug("Exited with code 0")
|
||||
None
|
||||
}
|
||||
else
|
||||
Some("Nonzero exit code: " + exitCode)
|
||||
}
|
||||
/** Runs the class 'mainClass' using the given classpath and options using the scala runner.*/
|
||||
def run(mainClass: String, classpath: Iterable[Path], options: Seq[String], log: Logger) =
|
||||
{
|
||||
createSettings(log)
|
||||
{
|
||||
(settings: Settings) =>
|
||||
{
|
||||
Control.trapUnit("Error during run: ", log)
|
||||
{
|
||||
val classpathURLs = classpath.map(_.asURL).toList
|
||||
val bootClasspath = FileUtilities.pathSplit(settings.bootclasspath.value)
|
||||
val extraURLs =
|
||||
for(pathString <- bootClasspath if pathString.length > 0) yield
|
||||
(new java.io.File(pathString)).toURI.toURL
|
||||
log.info("Running " + mainClass + " ...")
|
||||
log.debug(" Classpath:" + (classpathURLs ++ extraURLs).mkString("\n\t", "\n\t",""))
|
||||
executeTrapExit( ObjectRunner.run(classpathURLs ++ extraURLs, mainClass, options.toList), log )
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/** If mainClassOption is None, then the interactive scala interpreter is started with the given classpath.
|
||||
* Otherwise, the class wrapped by Some is run using the scala runner with the given classpath and
|
||||
* options. */
|
||||
def apply(mainClassOption: Option[String], classpath: Iterable[Path], options: Seq[String], log: Logger) =
|
||||
{
|
||||
mainClassOption match
|
||||
{
|
||||
case Some(mainClass) => run(mainClass, classpath, options, log)
|
||||
case None => console(classpath, log)
|
||||
}
|
||||
}
|
||||
/** Create a settings object and execute the provided function if the settings are created ok.*/
|
||||
private def createSettings(log: Logger)(f: Settings => Option[String]) =
|
||||
{
|
||||
val command = new GenericRunnerCommand(Nil, message => log.error(message))
|
||||
if(command.ok)
|
||||
f(command.settings)
|
||||
else
|
||||
Some(command.usageMsg)
|
||||
}
|
||||
|
||||
/** Starts a Scala interpreter session with 'project' bound to the value 'current' in the console
|
||||
* and the following two lines executed:
|
||||
* import sbt._
|
||||
* import current._
|
||||
*/
|
||||
def projectConsole(project: Project): Option[String] =
|
||||
{
|
||||
import project.log
|
||||
createSettings(log) { interpreterSettings =>
|
||||
createSettings(log) { compilerSettings =>
|
||||
log.info("Starting scala interpreter with project definition " + project.name + " ...")
|
||||
log.info("")
|
||||
Control.trapUnit("Error during session: ", log)
|
||||
{
|
||||
val loop = new ProjectInterpreterLoop(compilerSettings, project)
|
||||
executeTrapExit(loop.main(interpreterSettings), log)
|
||||
}
|
||||
}}
|
||||
}
|
||||
/** A custom InterpreterLoop with the purpose of creating an interpreter with Project 'project' bound to the value 'current',
|
||||
* and the following two lines interpreted:
|
||||
* import sbt._
|
||||
* import current._.
|
||||
* To do this,
|
||||
* 1) The compiler uses a different settings instance: 'compilerSettings', which will have its classpath set to include the classpath
|
||||
* of the loader that loaded 'project'. The compiler can then find the classes it needs to compile code referencing the project.
|
||||
* 2) The parent class loader for the interpreter is the loader that loaded the project, so that the project can be bound to a variable
|
||||
* in the interpreter.
|
||||
*/
|
||||
private class ProjectInterpreterLoop(compilerSettings: Settings, project: Project) extends InterpreterLoop
|
||||
{
|
||||
override def createInterpreter()
|
||||
{
|
||||
val loader = project.getClass.getClassLoader.asInstanceOf[URLClassLoader]
|
||||
compilerSettings.classpath.value = loader.getURLs.flatMap(ClasspathUtilities.asFile).map(_.getAbsolutePath).mkString(File.pathSeparator)
|
||||
project.log.debug(" Compiler classpath: " + compilerSettings.classpath.value)
|
||||
|
||||
in = InteractiveReader.createDefault()
|
||||
interpreter = new Interpreter(settings)
|
||||
{
|
||||
override protected def parentClassLoader = loader
|
||||
override protected def newCompiler(settings: Settings, reporter: Reporter) = super.newCompiler(compilerSettings, reporter)
|
||||
}
|
||||
interpreter.setContextClassLoader()
|
||||
interpreter.bind("current", project.getClass.getName, project)
|
||||
interpreter.interpret("import sbt._")
|
||||
interpreter.interpret("import Process._")
|
||||
interpreter.interpret("import current._")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,345 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah, David MacIver
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import FileUtilities._
|
||||
import java.io.File
|
||||
import java.util.jar.{Attributes, Manifest}
|
||||
import scala.collection.mutable.ListBuffer
|
||||
|
||||
trait SimpleScalaProject extends Project
|
||||
{
|
||||
def errorTask(message: String) = task{ Some(message) }
|
||||
|
||||
trait CleanOption extends ActionOption
|
||||
case class ClearAnalysis(analysis: TaskAnalysis[_, _, _]) extends CleanOption
|
||||
case class Preserve(paths: PathFinder) extends CleanOption
|
||||
|
||||
case class CompileOption(val asString: String) extends ActionOption
|
||||
case class JavaCompileOption(val asString: String) extends ActionOption
|
||||
|
||||
val Deprecation = CompileOption("-deprecation")
|
||||
val ExplainTypes = CompileOption("-explaintypes")
|
||||
val Optimize = CompileOption("-optimise")
|
||||
def Optimise = Optimize
|
||||
val Verbose = CompileOption("-verbose")
|
||||
val Unchecked = CompileOption("-unchecked")
|
||||
val DisableWarnings = CompileOption("-nowarn")
|
||||
def target(target: Target.Value) = CompileOption("-target:" + target)
|
||||
object Target extends Enumeration
|
||||
{
|
||||
val Java1_5 = Value("jvm-1.5")
|
||||
val Java1_4 = Value("jvm-1.4")
|
||||
val Msil = Value("msil")
|
||||
}
|
||||
|
||||
def cleanTask(paths: PathFinder, options: CleanOption*): Task =
|
||||
cleanTask(paths, options)
|
||||
def cleanTask(paths: PathFinder, options: => Seq[CleanOption]): Task =
|
||||
task
|
||||
{
|
||||
val cleanOptions = options
|
||||
val preservePaths = for(Preserve(preservePaths) <- cleanOptions; toPreserve <- preservePaths.get) yield toPreserve
|
||||
Control.thread(FileUtilities.preserve(preservePaths, log))
|
||||
{ preserved =>
|
||||
val pathClean = FileUtilities.clean(paths.get, log)
|
||||
for(ClearAnalysis(analysis) <- cleanOptions)
|
||||
{
|
||||
analysis.clear()
|
||||
analysis.save()
|
||||
}
|
||||
val restored = preserved.restore(log)
|
||||
pathClean orElse restored
|
||||
}
|
||||
}
|
||||
}
|
||||
trait ScalaProject extends SimpleScalaProject with FileTasks
|
||||
{
|
||||
import ScalaProject._
|
||||
|
||||
final case class MaxCompileErrors(val value: Int) extends CompileOption("") with ScaladocOption { def asList = Nil }
|
||||
trait PackageOption extends ActionOption
|
||||
trait TestOption extends ActionOption
|
||||
|
||||
case class TestSetup(setup: () => Option[String]) extends TestOption
|
||||
case class TestCleanup(cleanup: () => Option[String]) extends TestOption
|
||||
case class ExcludeTests(tests: Iterable[String]) extends TestOption
|
||||
case class TestListeners(listeners: Iterable[TestReportListener]) extends TestOption
|
||||
case class TestFilter(filterTest: String => Boolean) extends TestOption
|
||||
|
||||
case class JarManifest(m: Manifest) extends PackageOption
|
||||
{
|
||||
assert(m != null)
|
||||
}
|
||||
case class MainClass(mainClassName: String) extends PackageOption
|
||||
case class ManifestAttributes(attributes: (Attributes.Name, String)*) extends PackageOption
|
||||
case object Recursive extends PackageOption
|
||||
def ManifestAttributes(attributes: (String, String)*): ManifestAttributes =
|
||||
{
|
||||
val converted = for( (name,value) <- attributes ) yield (new Attributes.Name(name), value)
|
||||
new ManifestAttributes(converted : _*)
|
||||
}
|
||||
|
||||
|
||||
trait ScaladocOption extends ActionOption
|
||||
{
|
||||
def asList: List[String]
|
||||
}
|
||||
case class SimpleDocOption(optionValue: String) extends ScaladocOption
|
||||
{
|
||||
def asList = List(optionValue)
|
||||
}
|
||||
case class CompoundDocOption(label: String, value: String) extends ScaladocOption
|
||||
{
|
||||
def asList = List(label, value)
|
||||
}
|
||||
val LinkSource = SimpleDocOption("-linksource")
|
||||
val NoComment = SimpleDocOption("-nocomment")
|
||||
def access(access: Access.Value) = SimpleDocOption("-access:" + access)
|
||||
def documentBottom(bottomText: String) = CompoundDocOption("-bottom", bottomText)
|
||||
def documentCharset(charset: String) = CompoundDocOption("-charset", charset)
|
||||
def documentTitle(title: String) = CompoundDocOption("-doctitle", title)
|
||||
def documentFooter(footerText: String) = CompoundDocOption("-footer", footerText)
|
||||
def documentHeader(headerText: String) = CompoundDocOption("-header", headerText)
|
||||
def stylesheetFile(path: Path) = CompoundDocOption("-stylesheetfile", path.asFile.getAbsolutePath)
|
||||
def documentTop(topText: String) = CompoundDocOption("-top", topText)
|
||||
def windowTitle(title: String) = CompoundDocOption("-windowtitle", title)
|
||||
|
||||
object Access extends Enumeration
|
||||
{
|
||||
val Public = Value("public")
|
||||
val Default = Value("protected")
|
||||
val Private = Value("private")
|
||||
}
|
||||
|
||||
def consoleTask(classpath : PathFinder): Task =
|
||||
consoleTask(classpath, Run)
|
||||
def consoleTask(classpath : PathFinder, runner: ScalaRun): Task =
|
||||
interactiveTask { runner.console(classpath.get, log) }
|
||||
|
||||
def runTask(mainClass: => Option[String], classpath: PathFinder, options: String*): Task =
|
||||
runTask(mainClass, classpath, options)
|
||||
def runTask(mainClass: => Option[String], classpath: PathFinder, options: => Seq[String]): Task =
|
||||
runTask(mainClass, classpath, options, Run)
|
||||
def runTask(mainClass: => Option[String], classpath: PathFinder, options: => Seq[String], runner: ScalaRun): Task =
|
||||
task
|
||||
{
|
||||
mainClass match
|
||||
{
|
||||
case Some(main) => runner.run(main, classpath.get, options, log)
|
||||
case None => Some("No main class specified.")
|
||||
}
|
||||
}
|
||||
|
||||
def syncTask(sourceDirectory: Path, destinationDirectory: Path): Task =
|
||||
task { FileUtilities.sync(sourceDirectory, destinationDirectory, log) }
|
||||
def copyTask(sources: PathFinder, destinationDirectory: Path): Task =
|
||||
task { FileUtilities.copy(sources.get, destinationDirectory, log).left.toOption }
|
||||
|
||||
def testTask(frameworks: Iterable[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: TestOption*): Task =
|
||||
testTask(frameworks, classpath, analysis, options)
|
||||
def testTask(frameworks: Iterable[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: => Seq[TestOption]): Task =
|
||||
{
|
||||
def work =
|
||||
{
|
||||
val (begin, work, end) = testTasks(frameworks, classpath, analysis, options)
|
||||
val beginTasks = begin.map(toTask).toSeq // test setup tasks
|
||||
val workTasks = work.map(w => toTask(w) dependsOn(beginTasks : _*)) // the actual tests
|
||||
val endTasks = end.map(toTask).toSeq // tasks that perform test cleanup and are run regardless of success of tests
|
||||
val endTask = task { None } named("test-cleanup") dependsOn(endTasks : _*)
|
||||
val rootTask = task { None } named("test-complete") dependsOn(workTasks.toSeq : _*) // the task that depends on all test subtasks
|
||||
new SubWork[Project#Task](ParallelRunner.dagScheduler(rootTask), ParallelRunner.dagScheduler(endTask))
|
||||
}
|
||||
new CompoundTask(work)
|
||||
}
|
||||
private def toTask(testTask: NamedTestTask) = task(testTask.run()) named(testTask.name)
|
||||
|
||||
def graphTask(outputDirectory: Path, analysis: CompileAnalysis): Task = task { DotGraph(analysis, outputDirectory, log) }
|
||||
def scaladocTask(label: String, sources: PathFinder, outputDirectory: Path, classpath: PathFinder, options: ScaladocOption*): Task =
|
||||
scaladocTask(label, sources, outputDirectory, classpath, options)
|
||||
def scaladocTask(label: String, sources: PathFinder, outputDirectory: Path, classpath: PathFinder, options: => Seq[ScaladocOption]): Task =
|
||||
task
|
||||
{
|
||||
val classpathString = Path.makeString(classpath.get)
|
||||
val optionsLocal = options
|
||||
val maxErrors = maximumErrors(optionsLocal)
|
||||
(new Scaladoc(maxErrors))(label, sources.get, classpathString, outputDirectory, optionsLocal.flatMap(_.asList), log)
|
||||
}
|
||||
|
||||
def packageTask(sources: PathFinder, outputDirectory: Path, jarName: => String, options: PackageOption*): Task =
|
||||
packageTask(sources, outputDirectory / jarName, options)
|
||||
def packageTask(sources: PathFinder, outputDirectory: Path, jarName: => String, options: => Seq[PackageOption]): Task =
|
||||
packageTask(sources: PathFinder, outputDirectory / jarName, options)
|
||||
def packageTask(sources: PathFinder, jarPath: => Path, options: PackageOption*): Task =
|
||||
packageTask(sources, jarPath, options)
|
||||
def packageTask(sources: PathFinder, jarPath: => Path, options: => Seq[PackageOption]): Task =
|
||||
fileTask("package", jarPath from sources)
|
||||
{
|
||||
import wrap.{MutableMapWrapper,Wrappers}
|
||||
/** Copies the mappings in a2 to a1, mutating a1. */
|
||||
def mergeAttributes(a1: Attributes, a2: Attributes)
|
||||
{
|
||||
for( (key, value) <- Wrappers.toList(a2))
|
||||
a1.put(key, value)
|
||||
}
|
||||
|
||||
val manifest = new Manifest
|
||||
var recursive = false
|
||||
for(option <- options)
|
||||
{
|
||||
option match
|
||||
{
|
||||
case JarManifest(mergeManifest) =>
|
||||
{
|
||||
mergeAttributes(manifest.getMainAttributes, mergeManifest.getMainAttributes)
|
||||
val entryMap = new MutableMapWrapper(manifest.getEntries)
|
||||
for((key, value) <- Wrappers.toList(mergeManifest.getEntries))
|
||||
{
|
||||
entryMap.get(key) match
|
||||
{
|
||||
case Some(attributes) => mergeAttributes(attributes, value)
|
||||
case None => entryMap += (key, value)
|
||||
}
|
||||
}
|
||||
}
|
||||
case Recursive => recursive = true
|
||||
case MainClass(mainClassName) =>
|
||||
manifest.getMainAttributes.put(Attributes.Name.MAIN_CLASS, mainClassName)
|
||||
case ManifestAttributes(attributes @ _*) =>
|
||||
val main = manifest.getMainAttributes
|
||||
for( (name, value) <- attributes)
|
||||
main.put(name, value)
|
||||
case _ => log.warn("Ignored unknown package option " + option)
|
||||
}
|
||||
}
|
||||
val jarPathLocal = jarPath
|
||||
FileUtilities.clean(jarPathLocal :: Nil, log) orElse
|
||||
FileUtilities.jar(sources.get, jarPathLocal, manifest, recursive, log)
|
||||
}
|
||||
def zipTask(sources: PathFinder, outputDirectory: Path, zipName: => String): Task =
|
||||
zipTask(sources, outputDirectory / zipName)
|
||||
def zipTask(sources: PathFinder, zipPath: => Path): Task =
|
||||
fileTask("zip", zipPath from sources) { FileUtilities.zip(sources.get, zipPath, false, log) }
|
||||
def incrementVersionNumber()
|
||||
{
|
||||
projectVersion.get match
|
||||
{
|
||||
case Some(v: BasicVersion) =>
|
||||
{
|
||||
val newVersion = incrementImpl(v)
|
||||
log.info("Changing version to " + newVersion)
|
||||
projectVersion() = newVersion
|
||||
}
|
||||
case a => ()
|
||||
}
|
||||
}
|
||||
protected def incrementImpl(v: BasicVersion): Version = v.incrementMicro
|
||||
protected def testTasks(frameworks: Iterable[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: => Seq[TestOption]) = {
|
||||
import scala.collection.mutable.HashSet
|
||||
|
||||
val testFilters = new ListBuffer[String => Boolean]
|
||||
val excludeTestsSet = new HashSet[String]
|
||||
val setup, cleanup = new ListBuffer[() => Option[String]]
|
||||
val testListeners = new ListBuffer[TestReportListener]
|
||||
|
||||
options.foreach {
|
||||
case TestFilter(include) => testFilters += include
|
||||
case ExcludeTests(exclude) => excludeTestsSet ++= exclude
|
||||
case TestListeners(listeners) => testListeners ++= listeners
|
||||
case TestSetup(setupFunction) => setup += setupFunction
|
||||
case TestCleanup(cleanupFunction) => cleanup += cleanupFunction
|
||||
}
|
||||
|
||||
if(excludeTestsSet.size > 0 && log.atLevel(Level.Debug))
|
||||
{
|
||||
log.debug("Excluding tests: ")
|
||||
excludeTestsSet.foreach(test => log.debug("\t" + test))
|
||||
}
|
||||
def includeTest(test: TestDefinition) = !excludeTestsSet.contains(test.testClassName) && testFilters.forall(filter => filter(test.testClassName))
|
||||
val tests = HashSet.empty[TestDefinition] ++ analysis.allTests.filter(includeTest)
|
||||
TestFramework.testTasks(frameworks, classpath.get, tests, log, testListeners.readOnly, false, setup.readOnly, cleanup.readOnly)
|
||||
}
|
||||
private def flatten[T](i: Iterable[Iterable[T]]) = i.flatMap(x => x)
|
||||
|
||||
protected def testQuickMethod(testAnalysis: CompileAnalysis, options: => Seq[TestOption])(toRun: Seq[TestOption] => Task) =
|
||||
task { tests =>
|
||||
val (exactFilters, testFilters) = tests.toList.map(GlobFilter.apply).partition(_.isInstanceOf[ExactFilter])
|
||||
val includeTests = exactFilters.map(_.asInstanceOf[ExactFilter].matchName)
|
||||
val toCheck = scala.collection.mutable.HashSet(includeTests: _*)
|
||||
toCheck --= testAnalysis.allTests.map(_.testClassName)
|
||||
if(!toCheck.isEmpty && log.atLevel(Level.Warn))
|
||||
{
|
||||
log.warn("Test(s) not found:")
|
||||
toCheck.foreach(test => log.warn("\t" + test))
|
||||
}
|
||||
val includeTestsSet = scala.collection.mutable.HashSet(includeTests: _*)
|
||||
val newOptions =
|
||||
if(includeTests.isEmpty && testFilters.isEmpty) options
|
||||
else TestFilter(test => includeTestsSet.contains(test) || testFilters.exists(_.accept(test))) :: options.toList
|
||||
toRun(newOptions)
|
||||
} completeWith testAnalysis.allTests.map(_.testClassName).toList
|
||||
|
||||
protected final def maximumErrors[T <: ActionOption](options: Seq[T]) =
|
||||
(for( MaxCompileErrors(maxErrors) <- options) yield maxErrors).firstOption.getOrElse(DefaultMaximumCompileErrors)
|
||||
}
|
||||
trait WebScalaProject extends ScalaProject
|
||||
{
|
||||
@deprecated protected def prepareWebappTask(webappContents: PathFinder, warPath: => Path, classpath: PathFinder, extraJars: => Iterable[File]): Task =
|
||||
prepareWebappTask(webappContents, warPath, classpath, Path.lazyPathFinder(extraJars.map(Path.fromFile)))
|
||||
protected def prepareWebappTask(webappContents: PathFinder, warPath: => Path, classpath: PathFinder, extraJars: PathFinder): Task =
|
||||
task
|
||||
{
|
||||
val webInfPath = warPath / "WEB-INF"
|
||||
val webLibDirectory = webInfPath / "lib"
|
||||
val classesTargetDirectory = webInfPath / "classes"
|
||||
|
||||
val (libs, directories) = classpath.get.toList.partition(ClasspathUtilities.isArchive)
|
||||
val classesAndResources = descendents(Path.lazyPathFinder(directories) ##, "*")
|
||||
if(log.atLevel(Level.Debug))
|
||||
directories.foreach(d => log.debug(" Copying the contents of directory " + d + " to " + classesTargetDirectory))
|
||||
|
||||
import FileUtilities.{copy, copyFlat, copyFilesFlat, clean}
|
||||
(copy(webappContents.get, warPath, log).right flatMap { copiedWebapp =>
|
||||
copy(classesAndResources.get, classesTargetDirectory, log).right flatMap { copiedClasses =>
|
||||
copyFlat(libs, webLibDirectory, log).right flatMap { copiedLibs =>
|
||||
copyFilesFlat(extraJars.get.map(_.asFile), webLibDirectory, log).right flatMap { copiedExtraLibs =>
|
||||
{
|
||||
val toRemove = scala.collection.mutable.HashSet((warPath ** "*").get.toSeq : _*)
|
||||
toRemove --= copiedWebapp
|
||||
toRemove --= copiedClasses
|
||||
toRemove --= copiedLibs
|
||||
toRemove --= copiedExtraLibs
|
||||
val (directories, files) = toRemove.toList.partition(_.isDirectory)
|
||||
if(log.atLevel(Level.Debug))
|
||||
files.foreach(r => log.debug("Pruning file " + r))
|
||||
val result =
|
||||
clean(files, true, log) orElse
|
||||
{
|
||||
val emptyDirectories = directories.filter(directory => directory.asFile.listFiles.isEmpty)
|
||||
if(log.atLevel(Level.Debug))
|
||||
emptyDirectories.foreach(r => log.debug("Pruning directory " + r))
|
||||
clean(emptyDirectories, true, log)
|
||||
}
|
||||
result.toLeft(())
|
||||
}
|
||||
}}}}).left.toOption
|
||||
}
|
||||
def jettyRunTask(warPath: => Path, defaultContextPath: => String, port: Int, classpath: PathFinder, classpathName: String, scanDirectories: Seq[File], scanInterval: Int): Task =
|
||||
task { JettyRun(classpath.get, classpathName, warPath, defaultContextPath, port, scanDirectories, scanInterval, log) }
|
||||
def jettyRunTask(warPath: => Path, defaultContextPath: => String, classpath: PathFinder, classpathName: String, scanDirectories: Seq[File], scanInterval: Int): Task =
|
||||
jettyRunTask(warPath, defaultContextPath, JettyRun.DefaultPort, classpath, classpathName, scanDirectories, scanInterval)
|
||||
def jettyRunTask(warPath: => Path, defaultContextPath: => String, classpath: PathFinder, classpathName: String,
|
||||
jettyConfigurationXML: scala.xml.NodeSeq, jettyConfigurationFiles: Seq[File]): Task =
|
||||
task { JettyRun(classpath.get, classpathName, warPath, defaultContextPath, jettyConfigurationXML, jettyConfigurationFiles, log) }
|
||||
def jettyStopTask = task { JettyRun.stop(); None }
|
||||
}
|
||||
object ScalaProject
|
||||
{
|
||||
val DefaultMaximumCompileErrors = 100
|
||||
val AnalysisDirectoryName = "analysis"
|
||||
val MainClassKey = "Main-Class"
|
||||
val TestResourcesProperty = "sbt.test.resources"
|
||||
def optionsAsString(options: Seq[ScalaProject#CompileOption]) = options.map(_.asString).filter(!_.isEmpty)
|
||||
def javaOptionsAsString(options: Seq[ScalaProject#JavaCompileOption]) = options.map(_.asString)
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
/** Provides access to the current version of Scala being used to build a project. These methods typically
|
||||
* return None or the empty string when the loader is not used. */
|
||||
object ScalaVersion
|
||||
{
|
||||
/** The name of the system property containing the Scala version used for this project.*/
|
||||
private[sbt] val LiveKey = "sbt.scala.version"
|
||||
private[sbt] def crossString(v: String) = "scala_" + v
|
||||
/** Returns the current version of Scala being used to build the project, unless the sbt loader is not being used,
|
||||
* in which case this is the empty string.*/
|
||||
def currentString =
|
||||
{
|
||||
val v = System.getProperty(LiveKey)
|
||||
if(v == null)
|
||||
""
|
||||
else
|
||||
v.trim
|
||||
}
|
||||
/** Returns the current version of Scala being used to build the project. If the sbt loader is not being
|
||||
* used, this returns None. Otherwise, the value returned by this method is fixed for the duration of
|
||||
* a Project's existence. It only changes on reboot (during which a Project is recreated).*/
|
||||
val current: Option[String] =
|
||||
{
|
||||
val sv = currentString
|
||||
if(sv.isEmpty)
|
||||
None
|
||||
else
|
||||
Some(sv)
|
||||
}
|
||||
private[sbt] def withCross[T](crossDisabled: Boolean)(withVersion: String => T, disabled: => T): T =
|
||||
{
|
||||
if(crossDisabled)
|
||||
disabled
|
||||
else
|
||||
{
|
||||
current match
|
||||
{
|
||||
case Some(scalaV) => withVersion(scalaV)
|
||||
case _ => disabled
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mikko Peltonen, Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
object SourceModificationWatch
|
||||
{
|
||||
def watchUntil(project: Project, pollDelaySec: Int)(terminationCondition: => Boolean)(onSourcesModified: => Unit)
|
||||
{
|
||||
def sourceFiles: Iterable[java.io.File] =
|
||||
sourcesFinder.get.map(Path.relativize(project.info.projectPath, _)).filter(_.isDefined).map(_.get.asFile)
|
||||
def sourcesFinder: PathFinder = (Path.emptyPathFinder /: project.topologicalSort)(_ +++ _.watchPaths)
|
||||
def loop(lastCallbackCallTime: Long, previousFileCount: Int)
|
||||
{
|
||||
val (lastModifiedTime, fileCount) = sourceFiles.foldLeft((0L, 0)){(acc, file) => (Math.max(acc._1, file.lastModified), acc._2 + 1)}
|
||||
val newCallbackCallTime =
|
||||
// check if sources are modified
|
||||
if (lastModifiedTime > lastCallbackCallTime || previousFileCount != fileCount)
|
||||
{
|
||||
val now = System.currentTimeMillis
|
||||
onSourcesModified
|
||||
now
|
||||
}
|
||||
else
|
||||
lastCallbackCallTime
|
||||
Thread.sleep(pollDelaySec * 1000)
|
||||
if(!terminationCondition)
|
||||
loop(newCallbackCallTime, fileCount)
|
||||
}
|
||||
loop(0L, 0)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 David MacIver, Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
trait Described extends NotNull
|
||||
{
|
||||
def description: Option[String]
|
||||
}
|
||||
trait TaskManager{
|
||||
type ManagerType >: this.type <: TaskManager
|
||||
type ManagedTask >: Task <: TaskManager#Task with Dag[ManagedTask]
|
||||
/** Creates a task that executes the given action when invoked.*/
|
||||
def task(action : => Option[String]) = new Task(None, Nil, false, action)
|
||||
/** An interactive task is one that is not executed across all dependent projects when
|
||||
* it is called directly. The dependencies of the task are still invoked across all dependent
|
||||
* projects, however. */
|
||||
def interactiveTask(action: => Option[String]) = new Task(None, Nil, true, action)
|
||||
/** Creates a method task that executes the given action when invoked. */
|
||||
def task(action: Array[String] => ManagedTask) = new MethodTask(None, action, Nil)
|
||||
|
||||
def taskName(t: Task): String
|
||||
|
||||
/** A method task is an action that has parameters. Note that it is not a Task, though,
|
||||
* because it requires arguments to perform its work. It therefore cannot be a dependency of
|
||||
* a Task..*/
|
||||
final class MethodTask(val description: Option[String], action: Array[String] => ManagedTask, getCompletions: => Seq[String]) extends Described
|
||||
{
|
||||
/** Creates a new method task, identical to this method task, except with thE[String]e given description.*/
|
||||
def describedAs(description : String) = new MethodTask(Some(description), action, getCompletions)
|
||||
/** Invokes this method task with the given arguments.*/
|
||||
def apply(arguments: Array[String]) = action(arguments)
|
||||
def manager: ManagerType = TaskManager.this
|
||||
def completeWith(add: => Seq[String]) = new MethodTask(description, action, add)
|
||||
def completions = getCompletions
|
||||
}
|
||||
|
||||
sealed class Task(val explicitName: Option[String], val description : Option[String], val dependencies : List[ManagedTask],
|
||||
val interactive: Boolean, action : => Option[String]) extends Dag[ManagedTask] with Described
|
||||
{
|
||||
def this(description : Option[String], dependencies : List[ManagedTask], interactive: Boolean, action : => Option[String]) =
|
||||
this(None, description, dependencies, interactive, action)
|
||||
checkTaskDependencies(dependencies)
|
||||
def manager: ManagerType = TaskManager.this
|
||||
def name = explicitName.getOrElse(taskName(this))
|
||||
def named(name: String) = construct(Some(name), description,dependencies, interactive, action)
|
||||
override def toString = "Task " + name
|
||||
|
||||
/** Creates a new task, identical to this task, except with the additional dependencies specified.*/
|
||||
def dependsOn(tasks : ManagedTask*) = setDependencies(tasks.toList ::: dependencies)
|
||||
private[sbt] def setDependencies(dependencyList: List[ManagedTask]) =
|
||||
{
|
||||
checkTaskDependencies(dependencyList)
|
||||
construct(explicitName, description, dependencyList, interactive, action)
|
||||
}
|
||||
/** Creates a new task, identical to this task, except with the given description.*/
|
||||
def describedAs(description : String) = construct(explicitName, Some(description), dependencies, interactive, action);
|
||||
private[sbt] def invoke = action;
|
||||
|
||||
final def setInteractive = construct(explicitName, description, dependencies, true, action)
|
||||
final def run = runSequentially(topologicalSort)
|
||||
final def runDependenciesOnly = runSequentially(topologicalSort.dropRight(1))
|
||||
private def runSequentially(tasks: List[ManagedTask]) = Control.lazyFold(tasks)(_.invoke)
|
||||
|
||||
def &&(that : Task) =
|
||||
construct(explicitName, None, dependencies ::: that.dependencies, interactive || that.interactive, this.invoke.orElse(that.invoke))
|
||||
|
||||
protected def construct(explicitName: Option[String], description: Option[String], dependencies: List[ManagedTask], interactive: Boolean,
|
||||
action : => Option[String]): Task = new Task(explicitName, description, dependencies, interactive, action)
|
||||
}
|
||||
final class CompoundTask private (explicitName: Option[String], description : Option[String], dependencies : List[ManagedTask], interactive: Boolean,
|
||||
action : => Option[String], createWork: => SubWork[Project#Task]) extends Task(description, dependencies, interactive, action)
|
||||
with CompoundWork[Project#Task]
|
||||
{
|
||||
def this(createWork: => SubWork[Project#Task]) = this(None, None, Nil, false, None, createWork)
|
||||
override protected def construct(explicitName: Option[String], description: Option[String], dependencies: List[ManagedTask],
|
||||
interactive: Boolean, action : => Option[String]) = new CompoundTask(explicitName, description, dependencies, interactive, action, createWork)
|
||||
def work = createWork
|
||||
}
|
||||
|
||||
private def checkTaskDependencies(dependencyList: List[ManagedTask])
|
||||
{
|
||||
val nullDependencyIndex = dependencyList.findIndexOf(_ == null)
|
||||
require(nullDependencyIndex < 0, "Dependency (at index " + nullDependencyIndex + ") is null. This may be an initialization issue or a circular dependency.")
|
||||
val interactiveDependencyIndex = dependencyList.findIndexOf(_.interactive)
|
||||
require(interactiveDependencyIndex < 0, "Dependency (at index " + interactiveDependencyIndex + ") is interactive. Interactive tasks cannot be dependencies.")
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,221 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Steven Blundy, Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
object Result extends Enumeration
|
||||
{
|
||||
val Error, Passed, Failed = Value
|
||||
}
|
||||
object ClassType extends Enumeration
|
||||
{
|
||||
val Module, Class = Value
|
||||
}
|
||||
|
||||
trait TestFramework extends NotNull
|
||||
{
|
||||
def name: String
|
||||
def testSuperClassName: String
|
||||
def testSubClassType: ClassType.Value
|
||||
|
||||
def testRunner(classLoader: ClassLoader, listeners: Iterable[TestReportListener], log: Logger): TestRunner
|
||||
}
|
||||
trait TestRunner extends NotNull
|
||||
{
|
||||
def run(testClassName: String): Result.Value
|
||||
}
|
||||
|
||||
abstract class BasicTestRunner extends TestRunner
|
||||
{
|
||||
protected def log: Logger
|
||||
protected def listeners: Seq[TestReportListener]
|
||||
|
||||
final def run(testClass: String): Result.Value =
|
||||
{
|
||||
safeListenersCall(_.startGroup(testClass))
|
||||
try
|
||||
{
|
||||
val result = runTest(testClass)
|
||||
safeListenersCall(_.endGroup(testClass, result))
|
||||
result
|
||||
}
|
||||
catch
|
||||
{
|
||||
case e =>
|
||||
{
|
||||
safeListenersCall(_.endGroup(testClass, e))
|
||||
Result.Error
|
||||
}
|
||||
}
|
||||
}
|
||||
def runTest(testClass: String): Result.Value
|
||||
|
||||
protected def fire(event: TestEvent) = safeListenersCall(_.testEvent(event))
|
||||
protected def safeListenersCall(call: (TestReportListener) => Unit) = TestFramework.safeForeach(listeners, log)(call)
|
||||
}
|
||||
|
||||
final class NamedTestTask(val name: String, action: => Option[String]) extends NotNull { def run() = action }
|
||||
object TestFramework
|
||||
{
|
||||
def runTests(frameworks: Iterable[TestFramework], classpath: Iterable[Path], tests: Iterable[TestDefinition], log: Logger,
|
||||
listeners: Iterable[TestReportListener]) =
|
||||
{
|
||||
val (start, runTests, end) = testTasks(frameworks, classpath, tests, log, listeners, true, Nil, Nil)
|
||||
def run(tasks: Iterable[NamedTestTask]) = tasks.foreach(_.run())
|
||||
run(start)
|
||||
run(runTests)
|
||||
run(end)
|
||||
}
|
||||
|
||||
private val ScalaCompilerJarPackages = "scala.tools.nsc." :: "jline." :: "ch.epfl.lamp." :: Nil
|
||||
|
||||
private val TestStartName = "test-start"
|
||||
private val TestFinishName = "test-finish"
|
||||
|
||||
private[sbt] def safeForeach[T](it: Iterable[T], log: Logger)(f: T => Unit): Unit = it.foreach(i => Control.trapAndLog(log){ f(i) } )
|
||||
import scala.collection.{Map, Set}
|
||||
def testTasks(frameworks: Iterable[TestFramework], classpath: Iterable[Path], tests: Iterable[TestDefinition], log: Logger,
|
||||
listeners: Iterable[TestReportListener], endErrorsEnabled: Boolean, setup: Iterable[() => Option[String]],
|
||||
cleanup: Iterable[() => Option[String]]): (Iterable[NamedTestTask], Iterable[NamedTestTask], Iterable[NamedTestTask]) =
|
||||
{
|
||||
val mappedTests = testMap(frameworks, tests)
|
||||
if(mappedTests.isEmpty)
|
||||
(new NamedTestTask(TestStartName, None) :: Nil, Nil, new NamedTestTask(TestFinishName, { log.info("No tests to run."); None }) :: Nil )
|
||||
else
|
||||
createTestTasks(classpath, mappedTests, log, listeners, endErrorsEnabled, setup, cleanup)
|
||||
}
|
||||
private def testMap(frameworks: Iterable[TestFramework], tests: Iterable[TestDefinition]): Map[TestFramework, Set[String]] =
|
||||
{
|
||||
import scala.collection.mutable.{HashMap, HashSet, Set}
|
||||
val map = new HashMap[TestFramework, Set[String]]
|
||||
if(!frameworks.isEmpty)
|
||||
{
|
||||
for(test <- tests)
|
||||
{
|
||||
def isTestForFramework(framework: TestFramework) =
|
||||
(framework.testSubClassType == ClassType.Module) == test.isModule &&
|
||||
framework.testSuperClassName == test.superClassName
|
||||
|
||||
for(framework <- frameworks.find(isTestForFramework))
|
||||
map.getOrElseUpdate(framework, new HashSet[String]) += test.testClassName
|
||||
}
|
||||
}
|
||||
wrap.Wrappers.readOnly(map)
|
||||
}
|
||||
private def createTasks(work: Iterable[() => Option[String]], baseName: String) =
|
||||
work.toList.zipWithIndex.map{ case (work, index) => new NamedTestTask(baseName + " " + (index+1), work()) }
|
||||
|
||||
private def createTestTasks(classpath: Iterable[Path], tests: Map[TestFramework, Set[String]], log: Logger,
|
||||
listeners: Iterable[TestReportListener], endErrorsEnabled: Boolean, setup: Iterable[() => Option[String]],
|
||||
cleanup: Iterable[() => Option[String]]) =
|
||||
{
|
||||
val filterCompilerLoader = new FilteredLoader(getClass.getClassLoader, ScalaCompilerJarPackages)
|
||||
val loader: ClassLoader = new IntermediateLoader(classpath.map(_.asURL).toSeq.toArray, filterCompilerLoader)
|
||||
val testsListeners = listeners.filter(_.isInstanceOf[TestsListener]).map(_.asInstanceOf[TestsListener])
|
||||
def foreachListenerSafe(f: TestsListener => Unit): Unit = safeForeach(testsListeners, log)(f)
|
||||
|
||||
import Result.{Error,Passed,Failed}
|
||||
object result
|
||||
{
|
||||
private[this] var value: Result.Value = Passed
|
||||
def apply() = synchronized { value }
|
||||
def update(v: Result.Value): Unit = synchronized { if(value != Error) value = v }
|
||||
}
|
||||
val startTask = new NamedTestTask(TestStartName, {foreachListenerSafe(_.doInit); None}) :: createTasks(setup, "Test setup")
|
||||
val testTasks =
|
||||
tests flatMap { case (framework, testClassNames) =>
|
||||
|
||||
val runner = framework.testRunner(loader, listeners, log)
|
||||
for(testClassName <- testClassNames) yield
|
||||
{
|
||||
def runTest() =
|
||||
{
|
||||
val oldLoader = Thread.currentThread.getContextClassLoader
|
||||
Thread.currentThread.setContextClassLoader(loader)
|
||||
try {
|
||||
runner.run(testClassName) match
|
||||
{
|
||||
case Error => result() = Error; Some("ERROR occurred during testing.")
|
||||
case Failed => result() = Failed; Some("Test FAILED")
|
||||
case _ => None
|
||||
}
|
||||
}
|
||||
finally {
|
||||
Thread.currentThread.setContextClassLoader(oldLoader)
|
||||
}
|
||||
}
|
||||
new NamedTestTask(testClassName, runTest())
|
||||
}
|
||||
}
|
||||
def end() =
|
||||
{
|
||||
foreachListenerSafe(_.doComplete(result()))
|
||||
result() match
|
||||
{
|
||||
case Error => if(endErrorsEnabled) Some("ERROR occurred during testing.") else None
|
||||
case Failed => if(endErrorsEnabled) Some("One or more tests FAILED.") else None
|
||||
case Passed =>
|
||||
{
|
||||
log.info(" ")
|
||||
log.info("All tests PASSED.")
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
val endTask = new NamedTestTask(TestFinishName, end() ) :: createTasks(cleanup, "Test cleanup")
|
||||
(startTask, testTasks, endTask)
|
||||
}
|
||||
}
|
||||
|
||||
abstract class LazyTestFramework extends TestFramework
|
||||
{
|
||||
/** The class name of the the test runner that executes
|
||||
* tests for this framework.*/
|
||||
protected def testRunnerClassName: String
|
||||
|
||||
/** Creates an instance of the runner given by 'testRunnerClassName'.*/
|
||||
final def testRunner(projectLoader: ClassLoader, listeners: Iterable[TestReportListener], log: Logger): TestRunner =
|
||||
{
|
||||
val runnerClassName = testRunnerClassName
|
||||
val frameworkClasspath = FileUtilities.classLocation(getClass)
|
||||
val sbtURL = FileUtilities.sbtJar.toURI.toURL
|
||||
val lazyLoader = new LazyFrameworkLoader(runnerClassName, Array(frameworkClasspath, sbtURL), projectLoader, getClass.getClassLoader)
|
||||
val runnerClass = Class.forName(runnerClassName, true, lazyLoader).asSubclass(classOf[TestRunner])
|
||||
|
||||
runnerClass.getConstructor(classOf[Logger], classOf[Seq[TestReportListener]], classOf[ClassLoader]).newInstance(log, listeners, projectLoader)
|
||||
}
|
||||
}
|
||||
|
||||
/** The test framework definition for ScalaTest.*/
|
||||
object ScalaTestFramework extends LazyTestFramework
|
||||
{
|
||||
val name = "ScalaTest"
|
||||
val SuiteClassName = "org.scalatest.Suite"
|
||||
|
||||
def testSuperClassName = SuiteClassName
|
||||
def testSubClassType = ClassType.Class
|
||||
|
||||
def testRunnerClassName = "sbt.impl.ScalaTestRunner"
|
||||
}
|
||||
/** The test framework definition for ScalaCheck.*/
|
||||
object ScalaCheckFramework extends LazyTestFramework
|
||||
{
|
||||
val name = "ScalaCheck"
|
||||
val PropertiesClassName = "org.scalacheck.Properties"
|
||||
|
||||
def testSuperClassName = PropertiesClassName
|
||||
def testSubClassType = ClassType.Module
|
||||
|
||||
def testRunnerClassName = "sbt.impl.ScalaCheckRunner"
|
||||
}
|
||||
/** The test framework definition for specs.*/
|
||||
object SpecsFramework extends LazyTestFramework
|
||||
{
|
||||
val name = "specs"
|
||||
val SpecificationClassName = "org.specs.Specification"
|
||||
|
||||
def testSuperClassName = SpecificationClassName
|
||||
def testSubClassType = ClassType.Module
|
||||
|
||||
def testRunnerClassName = "sbt.impl.SpecsRunner"
|
||||
}
|
||||
|
|
@ -0,0 +1,316 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Steven Blundy, Mark Harrah
|
||||
*/
|
||||
|
||||
package sbt
|
||||
|
||||
trait TestReportListener
|
||||
{
|
||||
/** called for each class or equivalent grouping */
|
||||
def startGroup(name: String)
|
||||
/** called for each test method or equivalent */
|
||||
def testEvent(event: TestEvent)
|
||||
/** called if there was an error during test */
|
||||
def endGroup(name: String, t: Throwable)
|
||||
/** called if test completed */
|
||||
def endGroup(name: String, result: Result.Value)
|
||||
}
|
||||
|
||||
trait TestsListener extends TestReportListener
|
||||
{
|
||||
/** called once, at beginning. */
|
||||
def doInit
|
||||
/** called once, at end. */
|
||||
def doComplete(finalResult: Result.Value)
|
||||
/** called once, at end, if the test framework throws an exception. */
|
||||
@deprecated def doComplete(t: Throwable)
|
||||
}
|
||||
|
||||
abstract class WriterReportListener(val log: Logger) extends TestsListener
|
||||
{
|
||||
import java.io.{IOException, PrintWriter, Writer}
|
||||
import scala.collection.mutable.{Buffer, ListBuffer}
|
||||
|
||||
protected case class Summary(count: Int, failures: Int, errors: Int, skipped: Int, message: Option[String], cause: Option[Throwable]) extends NotNull
|
||||
private var out: Option[PrintWriter] = None
|
||||
private var groupCount: Int = 0
|
||||
private var groupFailures: Int = 0
|
||||
private var groupErrors: Int = 0
|
||||
private var groupSkipped: Int = 0
|
||||
private var groupMessages: Seq[String] = Nil
|
||||
|
||||
protected val passedEventHandler: TestEvent => Summary = (event: TestEvent) => event match
|
||||
{
|
||||
case SpecificationReportEvent(successes, failures, errors, skipped, desc, systems, subSpecs) => Summary(successes, failures, errors, skipped, None, None)
|
||||
case IgnoredEvent(name, Some(message)) => Summary(1, 0, 0, 1, Some(message), None)
|
||||
case IgnoredEvent(name, None) => Summary(1, 0, 0, 1, None, None)
|
||||
case _ => Summary(1, 0, 0, 0, None, None)
|
||||
}
|
||||
protected val failedEventHandler: TestEvent => Summary = (event: TestEvent) => event match
|
||||
{
|
||||
case FailedEvent(name, msg) => Summary(1, 1, 0, 0, Some("! " + name + ": " + msg), None)
|
||||
case TypedErrorEvent(name, event, Some(msg), cause) => Summary(1, 1, 0, 0, Some(event + " - " + name + ": " + msg), cause)
|
||||
case TypedErrorEvent(name, event, None, cause) => Summary(1, 1, 0, 0, Some(event + " - " + name), cause)
|
||||
case ErrorEvent(msg) => Summary(1, 1, 0, 0, Some(msg), None)
|
||||
case SpecificationReportEvent(successes, failures, errors, skipped, desc, systems, subSpecs) => Summary(successes + failures + errors + skipped, failures, errors, skipped, Some(desc), None)
|
||||
case _ => {log.warn("Unrecognized failure: " + event); Summary(1, 1, 0, 0, None, None)}
|
||||
}
|
||||
protected val errorEventHandler: TestEvent => Summary = (event: TestEvent) => event match
|
||||
{
|
||||
case FailedEvent(name, msg) => Summary(1, 0, 1, 0, Some("! " + name + ": " + msg), None)
|
||||
case TypedErrorEvent(name, event, Some(msg), cause) => Summary(1, 0, 1, 0, Some(event + " - " + name + ": " + msg), cause)
|
||||
case TypedErrorEvent(name, event, None, cause) => Summary(1, 0, 1, 0, Some(event + " - " + name), cause)
|
||||
case ErrorEvent(msg) => Summary(1, 0, 1, 0, Some(msg), None)
|
||||
case SpecificationReportEvent(successes, failures, errors, skipped, desc, systems, subSpecs) => Summary(successes + failures + errors + skipped, failures, errors, skipped, Some(desc), None)
|
||||
case _ => {log.warn("Unrecognized error: " + event); Summary(1, 0, 1, 0, None, None)}
|
||||
}
|
||||
protected def open: Writer
|
||||
protected def close =
|
||||
{
|
||||
onOut(_.close())
|
||||
out = None
|
||||
}
|
||||
def doInit = Control.trapAndLog(log){ out = Some(new PrintWriter(open)) }
|
||||
def doComplete(finalResult: Result.Value) =
|
||||
{
|
||||
finalResult match
|
||||
{
|
||||
case Result.Error => println("Error during Tests")
|
||||
case Result.Passed => println("All Tests Passed")
|
||||
case Result.Failed => println("Tests Failed")
|
||||
}
|
||||
close
|
||||
}
|
||||
def doComplete(t: Throwable) =
|
||||
{
|
||||
println("Exception in Test Framework")
|
||||
onOut(t.printStackTrace(_))
|
||||
close
|
||||
}
|
||||
def startGroup(name: String) =
|
||||
{
|
||||
groupCount = 0
|
||||
groupFailures = 0
|
||||
groupErrors = 0
|
||||
groupSkipped = 0
|
||||
groupMessages = Nil
|
||||
}
|
||||
def testEvent(event: TestEvent) = event.result match
|
||||
{
|
||||
case Some(result) =>
|
||||
{
|
||||
val Summary(count, failures, errors, skipped, msg, cause) = result match
|
||||
{
|
||||
case Result.Passed => passedEventHandler(event)
|
||||
case Result.Failed => failedEventHandler(event)
|
||||
case Result.Error => errorEventHandler(event)
|
||||
}
|
||||
groupCount += count
|
||||
groupFailures += failures
|
||||
groupErrors += errors
|
||||
groupSkipped += skipped
|
||||
groupMessages ++= msg.toList
|
||||
}
|
||||
case None => {}
|
||||
}
|
||||
def endGroup(name: String, t: Throwable) =
|
||||
{
|
||||
groupMessages = Nil
|
||||
println("Exception in " + name)
|
||||
onOut(t.printStackTrace(_))
|
||||
}
|
||||
def endGroup(name: String, result: Result.Value) =
|
||||
{
|
||||
result match
|
||||
{
|
||||
case Result.Error => println("Error: " + name + " - Count " + groupCount + ", Failed " + groupFailures + ", Errors " + groupErrors)
|
||||
case Result.Passed => println("Passed: " + name + " - Count " + groupCount + ", Failed " + groupFailures + ", Errors " + groupErrors)
|
||||
case Result.Failed => println("Failed: " + name + " - Count " + groupCount + ", Failed " + groupFailures + ", Errors " + groupErrors)
|
||||
}
|
||||
if(!groupMessages.isEmpty)
|
||||
{
|
||||
groupMessages.foreach(println(_))
|
||||
groupMessages = Nil
|
||||
println("")
|
||||
}
|
||||
}
|
||||
protected def onOut(f: PrintWriter => Unit) = Control.trapAndLog(log){
|
||||
out match
|
||||
{
|
||||
case Some(pw) => f(pw)
|
||||
case None => log.warn("Method called when output was not open")
|
||||
}
|
||||
}
|
||||
protected def println(s: String) = onOut(_.println(s))
|
||||
}
|
||||
|
||||
class FileReportListener(val file: Path, log: Logger) extends WriterReportListener(log)
|
||||
{
|
||||
def open = new java.io.FileWriter(file.asFile)
|
||||
}
|
||||
|
||||
abstract class TestEvent extends NotNull
|
||||
{
|
||||
def result: Option[Result.Value]
|
||||
}
|
||||
|
||||
sealed abstract class ScalaCheckEvent extends TestEvent
|
||||
final case class PassedEvent(name: String, msg: String) extends ScalaCheckEvent { def result = Some(Result.Passed) }
|
||||
final case class FailedEvent(name: String, msg: String) extends ScalaCheckEvent { def result = Some(Result.Failed) }
|
||||
|
||||
sealed abstract class ScalaTestEvent(val result: Option[Result.Value]) extends TestEvent
|
||||
final case class TypedEvent(name: String, `type`: String, msg: Option[String])(result: Option[Result.Value]) extends ScalaTestEvent(result)
|
||||
final case class TypedErrorEvent(name: String, `type`: String, msg: Option[String], cause: Option[Throwable])(result: Option[Result.Value]) extends ScalaTestEvent(result)
|
||||
final case class MessageEvent(msg: String) extends ScalaTestEvent(None)
|
||||
final case class ErrorEvent(msg: String) extends ScalaTestEvent(None)
|
||||
final case class IgnoredEvent(name: String, msg: Option[String]) extends ScalaTestEvent(Some(Result.Passed))
|
||||
|
||||
sealed abstract class SpecsEvent extends TestEvent
|
||||
final case class SpecificationReportEvent(successes: Int, failures: Int, errors: Int, skipped: Int, pretty: String, systems: Seq[SystemReportEvent], subSpecs: Seq[SpecificationReportEvent]) extends SpecsEvent
|
||||
{
|
||||
def result = if(errors > 0) Some(Result.Error) else if(failures > 0) Some(Result.Failed) else Some(Result.Passed)
|
||||
}
|
||||
final case class SystemReportEvent(description: String, verb: String, skippedSus:Option[Throwable], literateDescription: Option[Seq[String]], examples: Seq[ExampleReportEvent]) extends SpecsEvent { def result = None }
|
||||
final case class ExampleReportEvent(description: String, errors: Seq[Throwable], failures: Seq[RuntimeException], skipped: Seq[RuntimeException], subExamples: Seq[ExampleReportEvent]) extends SpecsEvent { def result = None }
|
||||
|
||||
trait EventOutput[E <: TestEvent]
|
||||
{
|
||||
def output(e: E): Unit
|
||||
}
|
||||
|
||||
sealed abstract class LazyEventOutput[E <: TestEvent](val log: Logger) extends EventOutput[E]
|
||||
|
||||
class ScalaCheckOutput(log: Logger) extends LazyEventOutput[ScalaCheckEvent](log)
|
||||
{
|
||||
def output(event: ScalaCheckEvent) = event match
|
||||
{
|
||||
case PassedEvent(name, msg) => log.info("+ " + name + ": " + msg)
|
||||
case FailedEvent(name, msg) => log.error("! " + name + ": " + msg)
|
||||
}
|
||||
}
|
||||
|
||||
class ScalaTestOutput(log: Logger) extends LazyEventOutput[ScalaTestEvent](log)
|
||||
{
|
||||
def output(event: ScalaTestEvent) = event match
|
||||
{
|
||||
case TypedEvent(name, event, Some(msg)) => log.info(event + " - " + name + ": " + msg)
|
||||
case TypedEvent(name, event, None) => log.info(event + " - " + name)
|
||||
case TypedErrorEvent(name, event, Some(msg), cause) => logError(event + " - " + name + ": " + msg, cause)
|
||||
case TypedErrorEvent(name, event, None, cause) => logError(event + " - " + name, cause)
|
||||
case MessageEvent(msg) => log.info(msg)
|
||||
case ErrorEvent(msg) => logError(msg, None)
|
||||
case IgnoredEvent(name, Some(msg)) => log.info("Test ignored - " + name + ": " + msg)
|
||||
case IgnoredEvent(name, None) => log.info("Test ignored - " + name)
|
||||
}
|
||||
private def logError(message: String, cause: Option[Throwable])
|
||||
{
|
||||
cause.foreach(x => log.trace(x))
|
||||
log.error(message)
|
||||
}
|
||||
}
|
||||
|
||||
class SpecsOutput(val log: Logger) extends EventOutput[SpecsEvent]
|
||||
{
|
||||
private val Indent = " "
|
||||
|
||||
def output(event: SpecsEvent) = event match
|
||||
{
|
||||
case sre: SpecificationReportEvent => reportSpecification(sre, "")
|
||||
case sre: SystemReportEvent => reportSystem(sre, "")
|
||||
case ere: ExampleReportEvent => reportExample(ere, "")
|
||||
}
|
||||
|
||||
/* The following is closely based on org.specs.runner.OutputReporter,
|
||||
* part of specs, which is Copyright 2007-2008 Eric Torreborre.
|
||||
* */
|
||||
|
||||
private def reportSpecification(specification: SpecificationReportEvent, padding: String)
|
||||
{
|
||||
val newIndent = padding + Indent
|
||||
reportSpecifications(specification.subSpecs, newIndent)
|
||||
reportSystems(specification.systems, newIndent)
|
||||
}
|
||||
private def reportSpecifications(specifications: Iterable[SpecificationReportEvent], padding: String)
|
||||
{
|
||||
for(specification <- specifications)
|
||||
reportSpecification(specification, padding)
|
||||
}
|
||||
private def reportSystems(systems: Iterable[SystemReportEvent], padding: String)
|
||||
{
|
||||
for(system <- systems)
|
||||
reportSystem(system, padding)
|
||||
}
|
||||
private def reportSystem(sus: SystemReportEvent, padding: String)
|
||||
{
|
||||
log.info(padding + sus.description + " " + sus.verb + sus.skippedSus.map(" (skipped: " + _.getMessage + ")").getOrElse(""))
|
||||
for(description <- sus.literateDescription)
|
||||
log.info(padding + description.mkString)
|
||||
reportExamples(sus.examples, padding)
|
||||
log.info(" ")
|
||||
}
|
||||
private def reportExamples(examples: Iterable[ExampleReportEvent], padding: String)
|
||||
{
|
||||
for(example <- examples)
|
||||
{
|
||||
reportExample(example, padding)
|
||||
reportExamples(example.subExamples, padding + Indent)
|
||||
}
|
||||
}
|
||||
private def status(example: ExampleReportEvent) =
|
||||
{
|
||||
if (example.errors.size + example.failures.size > 0)
|
||||
"x "
|
||||
else if (example.skipped.size > 0)
|
||||
"o "
|
||||
else
|
||||
"+ "
|
||||
}
|
||||
private def reportExample(example: ExampleReportEvent, padding: String)
|
||||
{
|
||||
log.info(padding + status(example) + example.description)
|
||||
for(skip <- example.skipped)
|
||||
{
|
||||
log.trace(skip)
|
||||
log.warn(padding + skip.toString)
|
||||
}
|
||||
for(e <- example.failures ++ example.errors)
|
||||
{
|
||||
log.trace(e)
|
||||
log.error(padding + e.toString)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class LogTestReportListener(val log: Logger) extends TestReportListener
|
||||
{
|
||||
lazy val scalaCheckOutput: EventOutput[ScalaCheckEvent] = createScalaCheckOutput
|
||||
lazy val scalaTestOutput: EventOutput[ScalaTestEvent] = createScalaTestOutput
|
||||
lazy val specsOutput: EventOutput[SpecsEvent] = createSpecsOutput
|
||||
|
||||
protected def createScalaCheckOutput = new ScalaCheckOutput(log)
|
||||
protected def createScalaTestOutput = new ScalaTestOutput(log)
|
||||
protected def createSpecsOutput = new SpecsOutput(log)
|
||||
|
||||
def startGroup(name: String) {}
|
||||
def testEvent(event: TestEvent)
|
||||
{
|
||||
log.debug("in testEvent:" + event)
|
||||
event match
|
||||
{
|
||||
case sce: ScalaCheckEvent => scalaCheckOutput.output(sce)
|
||||
case ste: ScalaTestEvent => scalaTestOutput.output(ste)
|
||||
case se: SpecsEvent => specsOutput.output(se)
|
||||
case e => handleOtherTestEvent(e)
|
||||
}
|
||||
}
|
||||
protected def handleOtherTestEvent(event: TestEvent) {}
|
||||
def endGroup(name: String, t: Throwable)
|
||||
{
|
||||
log.error("Could not run test " + name + ": " + t.toString)
|
||||
log.trace(t)
|
||||
}
|
||||
def endGroup(name: String, result: Result.Value)
|
||||
{
|
||||
log.debug("in endGroup:" + result)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,238 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah
|
||||
*
|
||||
* Partially based on exit trapping in Nailgun by Pete Kirkham,
|
||||
* copyright 2004, Martian Software, Inc
|
||||
* licensed under Apache 2.0 License.
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import scala.collection.Set
|
||||
import scala.reflect.Manifest
|
||||
|
||||
/** This provides functionality to catch System.exit calls to prevent the JVM from terminating.
|
||||
* This is useful for executing user code that may call System.exit, but actually exiting is
|
||||
* undesirable. This file handles the call to exit by disposing all top-level windows and interrupting
|
||||
* all user started threads. It does not stop the threads and does not call shutdown hooks. It is
|
||||
* therefore inappropriate to use this with code that requires shutdown hooks or creates threads that
|
||||
* do not terminate. This category of code should only be called by forking the JVM. */
|
||||
object TrapExit
|
||||
{
|
||||
/** Executes the given thunk in a context where System.exit(code) throws
|
||||
* a custom SecurityException, which is then caught and the exit code returned.
|
||||
* Otherwise, 0 is returned. No other exceptions are handled by this method.*/
|
||||
def apply(execute: => Unit, log: Logger): Int =
|
||||
{
|
||||
log.debug("Starting sandboxed run...")
|
||||
|
||||
/** Take a snapshot of the threads that existed before execution in order to determine
|
||||
* the threads that were created by 'execute'.*/
|
||||
val originalThreads = allThreads
|
||||
val code = new ExitCode
|
||||
val customThreadGroup = new ExitThreadGroup(new ExitHandler(Thread.getDefaultUncaughtExceptionHandler, originalThreads, code))
|
||||
val executionThread = new Thread(customThreadGroup, "run-main") { override def run() { execute } }
|
||||
|
||||
val originalSecurityManager = System.getSecurityManager
|
||||
try
|
||||
{
|
||||
val newSecurityManager = new TrapExitSecurityManager(originalSecurityManager, customThreadGroup)
|
||||
System.setSecurityManager(newSecurityManager)
|
||||
|
||||
executionThread.start()
|
||||
|
||||
log.debug("Waiting for threads to exit or System.exit to be called.")
|
||||
waitForExit(originalThreads, log)
|
||||
log.debug("Interrupting remaining threads (should be all daemons).")
|
||||
interruptAll(originalThreads) // should only be daemon threads left now
|
||||
log.debug("Sandboxed run complete..")
|
||||
code.value.getOrElse(0)
|
||||
}
|
||||
finally { System.setSecurityManager(originalSecurityManager) }
|
||||
}
|
||||
// wait for all non-daemon threads to terminate
|
||||
private def waitForExit(originalThreads: Set[Thread], log: Logger)
|
||||
{
|
||||
var daemonsOnly = true
|
||||
processThreads(originalThreads, thread =>
|
||||
if(!thread.isDaemon)
|
||||
{
|
||||
daemonsOnly = false
|
||||
waitOnThread(thread, log)
|
||||
}
|
||||
)
|
||||
if(!daemonsOnly)
|
||||
waitForExit(originalThreads, log)
|
||||
}
|
||||
/** Waits for the given thread to exit. */
|
||||
private def waitOnThread(thread: Thread, log: Logger)
|
||||
{
|
||||
log.debug("Waiting for thread " + thread.getName + " to exit")
|
||||
thread.join
|
||||
log.debug("\tThread " + thread.getName + " exited.")
|
||||
}
|
||||
/** Returns the exit code of the System.exit that caused the given Exception, or rethrows the exception
|
||||
* if its cause was not calling System.exit.*/
|
||||
private def exitCode(e: Throwable) =
|
||||
withCause[TrapExitSecurityException, Int](e)
|
||||
{exited => exited.exitCode}
|
||||
{other => throw other}
|
||||
/** Recurses into the causes of the given exception looking for a cause of type CauseType. If one is found, `withType` is called with that cause.
|
||||
* If not, `notType` is called with the root cause.*/
|
||||
private def withCause[CauseType <: Throwable, T](e: Throwable)(withType: CauseType => T)(notType: Throwable => T)(implicit mf: Manifest[CauseType]): T =
|
||||
{
|
||||
val clazz = mf.erasure
|
||||
if(clazz.isInstance(e))
|
||||
withType(e.asInstanceOf[CauseType])
|
||||
else
|
||||
{
|
||||
val cause = e.getCause
|
||||
if(cause == null)
|
||||
notType(e)
|
||||
else
|
||||
withCause(cause)(withType)(notType)(mf)
|
||||
}
|
||||
}
|
||||
|
||||
/** Returns all threads that are not in the 'system' thread group and are not the AWT implementation
|
||||
* thread (AWT-XAWT, AWT-Windows, ...)*/
|
||||
private def allThreads: Set[Thread] =
|
||||
{
|
||||
val allThreads = wrap.Wrappers.toList(Thread.getAllStackTraces.keySet)
|
||||
val threads = new scala.collection.mutable.HashSet[Thread]
|
||||
for(thread <- allThreads if !isSystemThread(thread))
|
||||
threads += thread
|
||||
threads
|
||||
}
|
||||
/** Returns true if the given thread is in the 'system' thread group and is an AWT thread other than
|
||||
* AWT-EventQueue or AWT-Shutdown.*/
|
||||
private def isSystemThread(t: Thread) =
|
||||
{
|
||||
val name = t.getName
|
||||
if(name.startsWith("AWT-"))
|
||||
!(name.startsWith("AWT-EventQueue") || name.startsWith("AWT-Shutdown"))
|
||||
else
|
||||
{
|
||||
val group = t.getThreadGroup
|
||||
(group != null) && (group.getName == "system")
|
||||
}
|
||||
}
|
||||
/** Calls the provided function for each thread in the system as provided by the
|
||||
* allThreads function except those in ignoreThreads.*/
|
||||
private def processThreads(ignoreThreads: Set[Thread], process: Thread => Unit)
|
||||
{
|
||||
allThreads.filter(thread => !ignoreThreads.contains(thread)).foreach(process)
|
||||
}
|
||||
/** Handles System.exit by disposing all frames and calling interrupt on all user threads */
|
||||
private def stopAll(originalThreads: Set[Thread])
|
||||
{
|
||||
disposeAllFrames()
|
||||
interruptAll(originalThreads)
|
||||
}
|
||||
private def disposeAllFrames()
|
||||
{
|
||||
val allFrames = java.awt.Frame.getFrames
|
||||
if(allFrames.length > 0)
|
||||
{
|
||||
allFrames.foreach(_.dispose) // dispose all top-level windows, which will cause the AWT-EventQueue-* threads to exit
|
||||
Thread.sleep(2000) // AWT Thread doesn't exit immediately, so wait to interrupt it
|
||||
}
|
||||
}
|
||||
// interrupt all threads that appear to have been started by the user
|
||||
private def interruptAll(originalThreads: Set[Thread]): Unit =
|
||||
processThreads(originalThreads, safeInterrupt)
|
||||
// interrupts the given thread, but first replaces the exception handler so that the InterruptedException is not printed
|
||||
private def safeInterrupt(thread: Thread)
|
||||
{
|
||||
if(!thread.getName.startsWith("AWT-"))
|
||||
{
|
||||
thread.setUncaughtExceptionHandler(new TrapInterrupt(thread.getUncaughtExceptionHandler))
|
||||
thread.interrupt
|
||||
}
|
||||
}
|
||||
// an uncaught exception handler that swallows InterruptedExceptions and otherwise defers to originalHandler
|
||||
private final class TrapInterrupt(originalHandler: Thread.UncaughtExceptionHandler) extends Thread.UncaughtExceptionHandler
|
||||
{
|
||||
def uncaughtException(thread: Thread, e: Throwable)
|
||||
{
|
||||
withCause[InterruptedException, Unit](e)
|
||||
{interrupted => ()}
|
||||
{other => originalHandler.uncaughtException(thread, e) }
|
||||
thread.setUncaughtExceptionHandler(originalHandler)
|
||||
}
|
||||
}
|
||||
/** An uncaught exception handler that delegates to the original uncaught exception handler except when
|
||||
* the cause was a call to System.exit (which generated a SecurityException)*/
|
||||
private final class ExitHandler(originalHandler: Thread.UncaughtExceptionHandler, originalThreads: Set[Thread], codeHolder: ExitCode) extends Thread.UncaughtExceptionHandler
|
||||
{
|
||||
def uncaughtException(t: Thread, e: Throwable)
|
||||
{
|
||||
try
|
||||
{
|
||||
codeHolder.set(exitCode(e)) // will rethrow e if it was not because of a call to System.exit
|
||||
stopAll(originalThreads)
|
||||
}
|
||||
catch
|
||||
{
|
||||
case _ => originalHandler.uncaughtException(t, e)
|
||||
}
|
||||
}
|
||||
}
|
||||
private final class ExitThreadGroup(handler: Thread.UncaughtExceptionHandler) extends ThreadGroup("trap.exit")
|
||||
{
|
||||
override def uncaughtException(t: Thread, e: Throwable) = handler.uncaughtException(t, e)
|
||||
}
|
||||
}
|
||||
private final class ExitCode extends NotNull
|
||||
{
|
||||
private var code: Option[Int] = None
|
||||
def set(c: Int): Unit = synchronized { code = code orElse Some(c) }
|
||||
def value: Option[Int] = synchronized { code }
|
||||
}
|
||||
/////// These two classes are based on similar classes in Nailgun
|
||||
/** A custom SecurityManager to disallow System.exit. */
|
||||
private final class TrapExitSecurityManager(delegateManager: SecurityManager, group: ThreadGroup) extends SecurityManager
|
||||
{
|
||||
import java.security.Permission
|
||||
override def checkExit(status: Int)
|
||||
{
|
||||
val stack = Thread.currentThread.getStackTrace
|
||||
if(stack == null || stack.exists(isRealExit))
|
||||
throw new TrapExitSecurityException(status)
|
||||
}
|
||||
/** This ensures that only actual calls to exit are trapped and not just calls to check if exit is allowed.*/
|
||||
private def isRealExit(element: StackTraceElement): Boolean =
|
||||
element.getClassName == "java.lang.Runtime" && element.getMethodName == "exit"
|
||||
override def checkPermission(perm: Permission)
|
||||
{
|
||||
if(delegateManager != null)
|
||||
delegateManager.checkPermission(perm)
|
||||
}
|
||||
override def checkPermission(perm: Permission, context: AnyRef)
|
||||
{
|
||||
if(delegateManager != null)
|
||||
delegateManager.checkPermission(perm, context)
|
||||
}
|
||||
override def getThreadGroup = group
|
||||
}
|
||||
/** A custom SecurityException that tries not to be caught.*/
|
||||
private final class TrapExitSecurityException(val exitCode: Int) extends SecurityException
|
||||
{
|
||||
private var accessAllowed = false
|
||||
def allowAccess
|
||||
{
|
||||
accessAllowed = true
|
||||
}
|
||||
override def printStackTrace = ifAccessAllowed(super.printStackTrace)
|
||||
override def toString = ifAccessAllowed(super.toString)
|
||||
override def getCause = ifAccessAllowed(super.getCause)
|
||||
override def getMessage = ifAccessAllowed(super.getMessage)
|
||||
override def fillInStackTrace = ifAccessAllowed(super.fillInStackTrace)
|
||||
override def getLocalizedMessage = ifAccessAllowed(super.getLocalizedMessage)
|
||||
private def ifAccessAllowed[T](f: => T): T =
|
||||
{
|
||||
if(accessAllowed)
|
||||
f
|
||||
else
|
||||
throw this
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
sealed trait Version extends NotNull
|
||||
case class BasicVersion(major: Int, minor: Option[Int], micro: Option[Int], extra: Option[String]) extends Version
|
||||
{
|
||||
import Version._
|
||||
require(major >= 0, "Major revision must be nonnegative.")
|
||||
require(minor.isDefined || micro.isEmpty, "Cannot define micro revision without defining minor revision.")
|
||||
requirePositive(minor)
|
||||
requirePositive(micro)
|
||||
require(isValidExtra(extra))
|
||||
|
||||
def incrementMicro = BasicVersion(major, minor orElse Some(0), increment(micro), extra)
|
||||
def incrementMinor = BasicVersion(major, increment(minor), micro, extra)
|
||||
def incrementMajor = BasicVersion(major+1, minor, micro, extra)
|
||||
|
||||
override def toString = major +
|
||||
minor.map(minorI => "." + minorI + micro.map(microI => "." + microI).getOrElse("")).getOrElse("") +
|
||||
extra.map(x => "-" + x).getOrElse("")
|
||||
}
|
||||
case class OpaqueVersion(value: String) extends Version
|
||||
{
|
||||
require(!value.trim.isEmpty)
|
||||
override def toString = value
|
||||
}
|
||||
object Version
|
||||
{
|
||||
private[sbt] def increment(i: Option[Int]) = Some(i.getOrElse(0) + 1)
|
||||
private[sbt] def requirePositive(i: Option[Int]) { i.foreach(x => require(x >= 0)) }
|
||||
|
||||
import java.util.regex.Pattern
|
||||
val versionPattern = Pattern.compile("""(\d+)(?:\.(\d+)(?:\.(\d+))?)?(?:-(.+))?""")
|
||||
def fromString(v: String): Either[String, Version] =
|
||||
{
|
||||
val trimmed = v.trim
|
||||
if(trimmed.isEmpty)
|
||||
Left("Version cannot be empty.")
|
||||
else
|
||||
{
|
||||
val matcher = versionPattern.matcher(trimmed)
|
||||
import matcher._
|
||||
if(matches)
|
||||
{
|
||||
def toOption(index: Int) =
|
||||
{
|
||||
val v = group(index)
|
||||
if(v == null) None else Some(v)
|
||||
}
|
||||
def toInt(index: Int) = toOption(index).map(_.toInt)
|
||||
val extra = toOption(4)
|
||||
if(isValidExtra(extra))
|
||||
Right(BasicVersion(group(1).toInt, toInt(2), toInt(3), extra))
|
||||
else
|
||||
Right(OpaqueVersion(trimmed))
|
||||
}
|
||||
else
|
||||
Right(OpaqueVersion(trimmed))
|
||||
}
|
||||
}
|
||||
def isValidExtra(e: Option[String]): Boolean = e.map(isValidExtra).getOrElse(true)
|
||||
def isValidExtra(s: String): Boolean = !(s.trim.isEmpty || s.exists(java.lang.Character.isISOControl))
|
||||
}
|
||||
|
|
@ -0,0 +1,245 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import java.net.{URL, URLClassLoader}
|
||||
import scala.xml.NodeSeq
|
||||
|
||||
object JettyRun extends ExitHook
|
||||
{
|
||||
val DefaultPort = 8080
|
||||
|
||||
ExitHooks.register(this)
|
||||
|
||||
def name = "jetty-shutdown"
|
||||
def runBeforeExiting() { stop() }
|
||||
private var running: Option[Stoppable] = None
|
||||
private def started(s: Stoppable) { running = Some(s) }
|
||||
def stop()
|
||||
{
|
||||
synchronized
|
||||
{
|
||||
running.foreach(_.stop())
|
||||
running = None
|
||||
}
|
||||
}
|
||||
def apply(classpath: Iterable[Path], classpathName: String, war: Path, defaultContextPath: String, jettyConfigurationXML: NodeSeq,
|
||||
jettyConfigurationFiles: Seq[File], log: Logger): Option[String] =
|
||||
run(classpathName, new JettyRunConfiguration(war, defaultContextPath, DefaultPort, jettyConfigurationXML,
|
||||
jettyConfigurationFiles, Nil, 0, toURLs(classpath)), log)
|
||||
def apply(classpath: Iterable[Path], classpathName: String, war: Path, defaultContextPath: String, port: Int, scanDirectories: Seq[File],
|
||||
scanPeriod: Int, log: Logger): Option[String] =
|
||||
run(classpathName, new JettyRunConfiguration(war, defaultContextPath, port, NodeSeq.Empty, Nil, scanDirectories, scanPeriod, toURLs(classpath)), log)
|
||||
private def toURLs(paths: Iterable[Path]) = paths.map(_.asURL).toSeq
|
||||
private def run(classpathName: String, configuration: JettyRunConfiguration, log: Logger): Option[String] =
|
||||
synchronized
|
||||
{
|
||||
import configuration._
|
||||
def runJetty() =
|
||||
{
|
||||
val baseLoader = this.getClass.getClassLoader
|
||||
val loader: ClassLoader = new SelectiveLoader(classpathURLs.toArray, baseLoader, "org.mortbay." :: "javax.servlet." :: Nil)
|
||||
val lazyLoader = new LazyFrameworkLoader(implClassName, Array(FileUtilities.sbtJar.toURI.toURL), loader, baseLoader)
|
||||
val runner = ModuleUtilities.getObject(implClassName, lazyLoader).asInstanceOf[JettyRun]
|
||||
runner(configuration, log)
|
||||
}
|
||||
|
||||
if(running.isDefined)
|
||||
Some("Jetty is already running.")
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
started(runJetty())
|
||||
None
|
||||
}
|
||||
catch
|
||||
{
|
||||
case e: NoClassDefFoundError => runError(e, "Jetty and its dependencies must be on the " + classpathName + " classpath: ", log)
|
||||
case e => runError(e, "Error running Jetty: ", log)
|
||||
}
|
||||
}
|
||||
}
|
||||
private val implClassName = "sbt.LazyJettyRun"
|
||||
|
||||
private def runError(e: Throwable, messageBase: String, log: Logger) =
|
||||
{
|
||||
log.trace(e)
|
||||
Some(messageBase + e.toString)
|
||||
}
|
||||
}
|
||||
|
||||
private trait Stoppable
|
||||
{
|
||||
def stop(): Unit
|
||||
}
|
||||
private trait JettyRun
|
||||
{
|
||||
def apply(configuration: JettyRunConfiguration, log: Logger): Stoppable
|
||||
}
|
||||
private class JettyRunConfiguration(val war: Path, val defaultContextPath: String, val port: Int,
|
||||
val jettyConfigurationXML: NodeSeq, val jettyConfigurationFiles: Seq[File],
|
||||
val scanDirectories: Seq[File], val scanInterval: Int, val classpathURLs: Seq[URL]) extends NotNull
|
||||
|
||||
/* This class starts Jetty.
|
||||
* NOTE: DO NOT actively use this class. You will see NoClassDefFoundErrors if you fail
|
||||
* to do so.Only use its name in JettyRun for reflective loading. This allows using
|
||||
* the Jetty libraries provided on the project classpath instead of requiring them to be
|
||||
* available on sbt's classpath at startup.
|
||||
*/
|
||||
private object LazyJettyRun extends JettyRun
|
||||
{
|
||||
import org.mortbay.jetty.{Handler, Server}
|
||||
import org.mortbay.jetty.nio.SelectChannelConnector
|
||||
import org.mortbay.jetty.webapp.WebAppContext
|
||||
import org.mortbay.log.Log
|
||||
import org.mortbay.util.Scanner
|
||||
import org.mortbay.xml.XmlConfiguration
|
||||
|
||||
import java.lang.ref.{Reference, WeakReference}
|
||||
|
||||
val DefaultMaxIdleTime = 30000
|
||||
|
||||
def apply(configuration: JettyRunConfiguration, log: Logger): Stoppable =
|
||||
{
|
||||
import configuration._
|
||||
val oldLog = Log.getLog
|
||||
Log.setLog(new JettyLogger(log))
|
||||
val server = new Server
|
||||
val useDefaults = jettyConfigurationXML.isEmpty && jettyConfigurationFiles.isEmpty
|
||||
|
||||
val listener =
|
||||
if(useDefaults)
|
||||
{
|
||||
configureDefaultConnector(server, port)
|
||||
def createLoader = new URLClassLoader(classpathURLs.toArray, this.getClass.getClassLoader)
|
||||
val webapp = new WebAppContext(war.absolutePath, defaultContextPath)
|
||||
webapp.setClassLoader(createLoader)
|
||||
server.setHandler(webapp)
|
||||
|
||||
Some(new Scanner.BulkListener {
|
||||
def filesChanged(files: java.util.List[_]) {
|
||||
reload(server, webapp.setClassLoader(createLoader), log)
|
||||
}
|
||||
})
|
||||
}
|
||||
else
|
||||
{
|
||||
for(x <- jettyConfigurationXML)
|
||||
(new XmlConfiguration(x.toString)).configure(server)
|
||||
for(file <- jettyConfigurationFiles)
|
||||
(new XmlConfiguration(file.toURI.toURL)).configure(server)
|
||||
None
|
||||
}
|
||||
|
||||
def configureScanner() =
|
||||
{
|
||||
if(listener.isEmpty || scanDirectories.isEmpty)
|
||||
None
|
||||
else
|
||||
{
|
||||
log.debug("Scanning for changes to: " + scanDirectories.mkString(", "))
|
||||
val scanner = new Scanner
|
||||
val list = new java.util.ArrayList[File]
|
||||
scanDirectories.foreach(x => list.add(x))
|
||||
scanner.setScanDirs(list)
|
||||
scanner.setRecursive(true)
|
||||
scanner.setScanInterval(scanInterval)
|
||||
scanner.setReportExistingFilesOnStartup(false)
|
||||
scanner.addListener(listener.get)
|
||||
scanner.start()
|
||||
Some(new WeakReference(scanner))
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
server.start()
|
||||
new StopServer(new WeakReference(server), configureScanner(), oldLog)
|
||||
}
|
||||
catch { case e => server.stop(); throw e }
|
||||
}
|
||||
private def configureDefaultConnector(server: Server, port: Int)
|
||||
{
|
||||
val defaultConnector = new SelectChannelConnector
|
||||
defaultConnector.setPort(port)
|
||||
defaultConnector.setMaxIdleTime(DefaultMaxIdleTime)
|
||||
server.addConnector(defaultConnector)
|
||||
}
|
||||
private class StopServer(serverReference: Reference[Server], scannerReferenceOpt: Option[Reference[Scanner]], oldLog: org.mortbay.log.Logger) extends Stoppable
|
||||
{
|
||||
def stop()
|
||||
{
|
||||
val server = serverReference.get
|
||||
if(server != null)
|
||||
server.stop()
|
||||
for(scannerReference <- scannerReferenceOpt)
|
||||
{
|
||||
val scanner = scannerReference.get
|
||||
if(scanner != null)
|
||||
scanner.stop()
|
||||
}
|
||||
Log.setLog(oldLog)
|
||||
}
|
||||
}
|
||||
private def reload(server: Server, reconfigure: => Unit, log: Logger)
|
||||
{
|
||||
JettyRun.synchronized
|
||||
{
|
||||
log.info("Reloading web application...")
|
||||
val handlers = wrapNull(server.getHandlers, server.getHandler)
|
||||
log.debug("Stopping handlers: " + handlers.mkString(", "))
|
||||
handlers.foreach(_.stop)
|
||||
log.debug("Reconfiguring...")
|
||||
reconfigure
|
||||
log.debug("Restarting handlers: " + handlers.mkString(", "))
|
||||
handlers.foreach(_.start)
|
||||
log.info("Reload complete.")
|
||||
}
|
||||
}
|
||||
private def wrapNull(a: Array[Handler], b: Handler) =
|
||||
(a, b) match
|
||||
{
|
||||
case (null, null) => Nil
|
||||
case (null, notB) => notB :: Nil
|
||||
case (notA, null) => notA.toList
|
||||
case (notA, notB) => notB :: notA.toList
|
||||
}
|
||||
private class JettyLogger(delegate: Logger) extends org.mortbay.log.Logger
|
||||
{
|
||||
def isDebugEnabled = delegate.atLevel(Level.Debug)
|
||||
def setDebugEnabled(enabled: Boolean) = delegate.setLevel(if(enabled) Level.Debug else Level.Info)
|
||||
|
||||
def getLogger(name: String) = this
|
||||
def info(msg: String, arg0: AnyRef, arg1: AnyRef) { delegate.info(format(msg, arg0, arg1)) }
|
||||
def debug(msg: String, arg0: AnyRef, arg1: AnyRef) { delegate.debug(format(msg, arg0, arg1)) }
|
||||
def warn(msg: String, arg0: AnyRef, arg1: AnyRef) { delegate.warn(format(msg, arg0, arg1)) }
|
||||
def warn(msg: String, th: Throwable)
|
||||
{
|
||||
delegate.warn(msg)
|
||||
delegate.trace(th)
|
||||
}
|
||||
def debug(msg: String, th: Throwable)
|
||||
{
|
||||
delegate.debug(msg)
|
||||
delegate.trace(th)
|
||||
}
|
||||
private def format(msg: String, arg0: AnyRef, arg1: AnyRef) =
|
||||
{
|
||||
def toString(arg: AnyRef) = if(arg == null) "" else arg.toString
|
||||
val pieces = msg.split("""\{\}""", 3)
|
||||
if(pieces.length == 1)
|
||||
pieces(0)
|
||||
else
|
||||
{
|
||||
val base = pieces(0) + toString(arg0) + pieces(1)
|
||||
if(pieces.length == 2)
|
||||
base
|
||||
else
|
||||
base + toString(arg1) + pieces(2)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.io.File
|
||||
import scala.xml.{Elem, NodeSeq}
|
||||
import Control._
|
||||
|
||||
/** Defines the configurable parameters for the webstart task. */
|
||||
trait WebstartOptions extends NotNull
|
||||
{
|
||||
/** The main jar to use for webstart.*/
|
||||
def webstartMainJar: Path
|
||||
/** The location to put all generated files for webstart.*/
|
||||
def webstartOutputDirectory: Path
|
||||
/** Generates the .jnlp file using the provided resource descriptions. Each resource description
|
||||
* provides the path of the jar relative to 'webstartOutputDirectory' and whether or not
|
||||
* it is the main jar.*/
|
||||
def jnlpXML(jars: Seq[WebstartJarResource]): Elem
|
||||
/** The location to write the .jnlp file to. It must be in 'webstartOutputDirectory'.*/
|
||||
def jnlpFile: Path
|
||||
/** The location to put all jars that are not the main jar. It must be in 'webstartOutputDirectory'.*/
|
||||
def webstartLibDirectory: Path
|
||||
/** The libraries needed for webstart. Note that only jars are used; directories are discarded.*/
|
||||
def webstartLibraries: PathFinder
|
||||
/** Libraries external to the project needed for webstart. This is mainly for scala libraries.*/
|
||||
def webstartExtraLibraries: PathFinder
|
||||
/** Resources to copy to the webstart output directory.*/
|
||||
def webstartResources: PathFinder
|
||||
/** If defined, this specifies where to create a zip of the webstart output directory. It cannot be
|
||||
* in the output directory.*/
|
||||
def webstartZip: Option[Path]
|
||||
|
||||
/** If defined, configures signing of jars. All jars (main and libraries) are signed using
|
||||
* this configuration.*/
|
||||
def webstartSignConfiguration: Option[SignConfiguration]
|
||||
/** If true, pack200 compression is applied to all jars (main and libraries). A version of each jar
|
||||
* without pack200 compression is still created in the webstart output directory.*/
|
||||
def webstartPack200: Boolean
|
||||
/** If true, gzip compression will be applied to all jars. If pack200 compression is enabled,
|
||||
* gzip compression is also applied to the archives with pack200 compression. A version of
|
||||
* each file without gzip compression is still created in the webstart output directory. */
|
||||
def webstartGzip: Boolean
|
||||
}
|
||||
/** Represents a library included in the webstart distribution. Name is the filename of the jar.
|
||||
* href is the path of the jar relative to the webstart output directory. isMain is true only for
|
||||
* the main jar. */
|
||||
final class WebstartJarResource(val name: String, val href: String, val isMain: Boolean) extends NotNull
|
||||
/** Configuration for signing jars. */
|
||||
final class SignConfiguration(val alias: String, val options: Seq[SignJar.SignOption]) extends NotNull
|
||||
/** A scala project that produces a webstart distribution. */
|
||||
trait WebstartScalaProject extends ScalaProject
|
||||
{
|
||||
import WebstartScalaProject._
|
||||
/** Creates a task that produces a webstart distribution using the given options.*/
|
||||
def webstartTask(options: WebstartOptions) =
|
||||
task
|
||||
{
|
||||
import options._
|
||||
FileUtilities.createDirectories(webstartOutputDirectory :: webstartLibDirectory :: Nil, log) // ignore errors
|
||||
verifyOptions(options)
|
||||
|
||||
def relativize(jar: Path) = Path.relativize(webstartOutputDirectory ##, jar) getOrElse
|
||||
error("Jar (" + jar + ") was not in webstart output directory (" + webstartOutputDirectory + ").")
|
||||
def signAndPack(jars: List[Path], targetDirectory: Path): Either[String, List[Path]] =
|
||||
{
|
||||
lazyFold(jars, Nil: List[Path])
|
||||
{ (allJars, jar) =>
|
||||
val signPackResult =
|
||||
webstartSignConfiguration match
|
||||
{
|
||||
case Some(config) =>
|
||||
if(webstartPack200)
|
||||
signAndPack200(jar, config, targetDirectory, log)
|
||||
else
|
||||
signOnly(jar, config, targetDirectory, log)
|
||||
case None =>
|
||||
if(webstartPack200)
|
||||
pack200Only(jar, targetDirectory, log)
|
||||
else
|
||||
copyJar(jar, targetDirectory, log).right.map(jars => new Jars(jars, Nil))
|
||||
}
|
||||
val deleteOriginal = webstartPack200
|
||||
signPackResult.right flatMap { addJars =>
|
||||
if(webstartGzip)
|
||||
Control.lazyFold(addJars.gzippable, addJars.allJars ::: allJars)
|
||||
{ (accumulate, jar) => gzipJar(jar, deleteOriginal, log).right.map(_ ::: accumulate) }
|
||||
else
|
||||
Right(addJars.allJars ::: allJars)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
import FileUtilities._
|
||||
|
||||
val jars = (webstartLibraries +++ webstartExtraLibraries).get.filter(ClasspathUtilities.isArchive)
|
||||
def process(jars: Iterable[Path]) = for(jar <- jars if jar.asFile.getName.endsWith(".jar")) yield relativize(jar)
|
||||
|
||||
thread(signAndPack(webstartMainJar :: Nil, webstartOutputDirectory)) { mainJars =>
|
||||
thread(signAndPack(jars.toList, webstartLibDirectory)) { libJars =>
|
||||
writeXML(jnlpXML(jarResources(process(mainJars), process(libJars))), jnlpFile, log) orElse
|
||||
thread(copy(webstartResources.get, webstartOutputDirectory, log)) { copiedResources =>
|
||||
val keep = jnlpFile +++ Path.lazyPathFinder(mainJars ++ libJars ++ copiedResources) +++
|
||||
webstartOutputDirectory +++ webstartLibDirectory
|
||||
prune(webstartOutputDirectory, keep.get, log) orElse
|
||||
webstartZip.flatMap( zipPath => zip(List(webstartOutputDirectory ##), zipPath, true, log) )
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Creates default XML elements for a JNLP file for the given resources.*/
|
||||
protected def defaultElements(resources: Seq[WebstartJarResource]): NodeSeq = NodeSeq.fromSeq(resources.map(defaultElement))
|
||||
/** Creates a default XML element for a JNLP file for the given resource.*/
|
||||
protected def defaultElement(resource: WebstartJarResource): Elem =
|
||||
<jar href={resource.href} main={resource.isMain.toString}/>
|
||||
|
||||
}
|
||||
private class Jars(val gzippable: List[Path], val nonGzippable: List[Path]) extends NotNull
|
||||
{
|
||||
def allJars = gzippable ::: nonGzippable
|
||||
}
|
||||
private object WebstartScalaProject
|
||||
{
|
||||
import FileTasks.{runOption, wrapProduct, wrapProducts}
|
||||
/** Changes the extension of the Path of the given jar from ".jar" to newExtension. If append is true,
|
||||
* the new extension is simply appended to the jar's filename. */
|
||||
private def appendExtension(jar: Path, newExtension: String) =
|
||||
jar match
|
||||
{
|
||||
case rp: RelativePath => rp.parentPath / (rp.component + newExtension)
|
||||
case x => x
|
||||
}
|
||||
private def gzipJarPath(jar: Path) = appendExtension(jar, ".gz")
|
||||
private def packPath(jar: Path) = appendExtension(jar, ".pack")
|
||||
private def signOnly(jar: Path, signConfiguration: SignConfiguration, targetDirectory: Path, log: Logger) =
|
||||
{
|
||||
val targetJar = targetDirectory / jar.asFile.getName
|
||||
runOption("sign", targetJar from jar, log) {
|
||||
log.debug("Signing " + jar)
|
||||
signAndVerify(jar, signConfiguration, targetJar, log)
|
||||
}.toLeft(new Jars(targetJar :: Nil, Nil))
|
||||
}
|
||||
private def signAndVerify(jar: Path, signConfiguration: SignConfiguration, targetJar: Path, log: Logger) =
|
||||
{
|
||||
import SignJar._
|
||||
sign(jar, signConfiguration.alias, signedJar(targetJar) :: signConfiguration.options.toList, log) orElse
|
||||
verify(jar, signConfiguration.options, log).map(err => "Signed jar failed verification: " + err)
|
||||
}
|
||||
private def gzipJar(jar: Path, deleteOriginal: Boolean, log: Logger) =
|
||||
{
|
||||
val gzipJar = gzipJarPath(jar)
|
||||
runOption("gzip", gzipJar from jar, log)
|
||||
{
|
||||
log.debug("Gzipping " + jar)
|
||||
FileUtilities.gzip(jar, gzipJar, log) orElse
|
||||
(if(deleteOriginal) FileUtilities.clean(jar :: Nil, true, log) else None)
|
||||
}.toLeft(gzipJar :: Nil)
|
||||
}
|
||||
/** Properly performs both signing and pack200 compression and verifies the result. This method only does anything if
|
||||
* its outputs are out of date with respect to 'jar'. Note that it does not determine if the signing configuration has changed.
|
||||
* See java.util.jar.Pack200 for more information.*/
|
||||
private def signAndPack200(jar: Path, signConfiguration: SignConfiguration, targetDirectory: Path, log: Logger) =
|
||||
{
|
||||
val signedJar = targetDirectory / jar.asFile.getName
|
||||
val packedJar = packPath(signedJar)
|
||||
import signConfiguration._
|
||||
|
||||
runOption("sign and pack200", List(packedJar, signedJar) from jar, log) {
|
||||
log.debug("Applying pack200 compression and signing " + jar)
|
||||
signAndPack(jar, signedJar, packedJar, alias, options, log) orElse
|
||||
signAndVerify(jar, signConfiguration, signedJar, log)
|
||||
}.toLeft(new Jars(packedJar :: Nil, signedJar :: Nil))
|
||||
}
|
||||
/** Properly performs both signing and pack200 compression and verifies the result. See java.util.jar.Pack200 for more information.*/
|
||||
private def signAndPack(jarPath: Path, signedPath: Path, out: Path, alias: String, options: Seq[SignJar.SignOption], log: Logger): Option[String] =
|
||||
{
|
||||
import Pack._
|
||||
import SignJar._
|
||||
pack(jarPath, out, log) orElse
|
||||
unpack(out, signedPath, log) orElse
|
||||
sign(signedPath, alias, options, log) orElse
|
||||
pack(signedPath, out, log) orElse
|
||||
unpack(out, signedPath, log) orElse
|
||||
verify(signedPath, options, log)
|
||||
}
|
||||
private def pack200Only(jar: Path, targetDirectory: Path, log: Logger) =
|
||||
{
|
||||
val targetJar = targetDirectory / jar.asFile.getName
|
||||
val packedJar = packPath(targetJar)
|
||||
val packResult =
|
||||
runOption("pack200", packedJar from jar, log)
|
||||
{
|
||||
log.debug("Applying pack200 compression to " + jar)
|
||||
Pack.pack(jar, packedJar, log)
|
||||
}
|
||||
packResult match
|
||||
{
|
||||
case Some(err) => Left(err)
|
||||
case None => copyJar(jar, targetDirectory, log).right.map(jars => new Jars(packedJar :: Nil, jars))
|
||||
}
|
||||
}
|
||||
private def copyJar(jar: Path, targetDirectory: Path, log: Logger) =
|
||||
{
|
||||
val targetJar = targetDirectory / jar.asFile.getName
|
||||
runOption("copy jar", targetJar from jar, log)( FileUtilities.copyFile(jar, targetJar, log) ).toLeft(targetJar :: Nil)
|
||||
}
|
||||
/** Writes the XML string 'xmlString' to the file 'outputPath'.*/
|
||||
private def writeXML(xmlString: String, outputPath: Path, log: Logger): Option[String] =
|
||||
FileUtilities.write(outputPath.asFile, xmlString, log)
|
||||
/** Writes the XML string 'xmlString' to the file 'outputPath' if the hashes are different.*/
|
||||
private def writeXML(xml: Elem, outputPath: Path, log: Logger): Option[String] =
|
||||
{
|
||||
val xmlString = scala.xml.Utility.toXML(xml, false)
|
||||
if(!outputPath.exists)
|
||||
{
|
||||
log.debug("JNLP file did not exist, writing inline XML to " + outputPath)
|
||||
writeXML(xmlString, outputPath, log)
|
||||
}
|
||||
else
|
||||
{
|
||||
val result =
|
||||
for( xmlHash <- Hash(xmlString, log).right; fileHash <- Hash(outputPath, log).right ) yield
|
||||
{
|
||||
if(xmlHash deepEquals fileHash)
|
||||
{
|
||||
log.debug("JNLP file " + outputPath + " uptodate.")
|
||||
None
|
||||
}
|
||||
else
|
||||
{
|
||||
log.debug("Inline JNLP XML modified, updating file " + outputPath + ".")
|
||||
writeXML(xmlString, outputPath, log)
|
||||
}
|
||||
}
|
||||
result.fold(err => Some(err), x => x)
|
||||
}
|
||||
}
|
||||
private def jarResource(isMain: Boolean)(jar: Path): WebstartJarResource =
|
||||
new WebstartJarResource(jar.asFile.getName, jar.relativePathString("/"), isMain)
|
||||
private def jarResources(mainJars: Iterable[Path], libraries: Iterable[Path]): Seq[WebstartJarResource] =
|
||||
mainJars.map(jarResource(true)).toList ::: libraries.map(jarResource(false)).toList
|
||||
|
||||
/** True iff 'directory' is an ancestor (strictly) of 'check'.*/
|
||||
private def isInDirectory(directory: Path, check: Path) = Path.relativize(directory, check).isDefined && directory != check
|
||||
/** Checks the paths in the given options for validity. See the documentation for WebstartOptions.*/
|
||||
private def verifyOptions(options: WebstartOptions)
|
||||
{
|
||||
import options._
|
||||
require(isInDirectory(webstartOutputDirectory, webstartLibDirectory),
|
||||
"Webstart dependency directory (" + webstartLibDirectory + ") must be a subdirectory of webstart output directory (" +
|
||||
webstartOutputDirectory + ").")
|
||||
require(isInDirectory(webstartOutputDirectory, jnlpFile), "Webstart JNLP file output location (" + jnlpFile +
|
||||
") must be in the webstart output directory (" + webstartOutputDirectory + ").")
|
||||
for(wz <- webstartZip)
|
||||
require(!isInDirectory(webstartOutputDirectory, wz),
|
||||
"Webstart output zip location (" + wz + " cannot be in webstart output directory (" + webstartOutputDirectory + ").")
|
||||
}
|
||||
}
|
||||
/** The default extension point for a webstart project. There is one method that is required to be defined: jnlpXML.
|
||||
* 'webstartSignConfiguration', 'webstartPack200', and 'webstartGzip' are methods of interest. */
|
||||
abstract class DefaultWebstartProject(val info: ProjectInfo) extends BasicWebstartProject with MavenStyleWebstartPaths
|
||||
/** Defines default implementations of all methods in WebstartOptions except for jnlpXML. packageAction is overridden
|
||||
* to create a webstart distribution after the normal package operation. */
|
||||
abstract class BasicWebstartProject extends BasicScalaProject with WebstartScalaProject with WebstartOptions with WebstartPaths
|
||||
{
|
||||
def webstartSignConfiguration: Option[SignConfiguration] = None
|
||||
|
||||
def webstartExtraLibraries = mainDependencies.scalaJars
|
||||
def webstartLibraries = publicClasspath +++ jarsOfProjectDependencies
|
||||
def webstartResources = descendents(jnlpResourcesPath ##, AllPassFilter)
|
||||
|
||||
def webstartPack200 = true
|
||||
def webstartGzip = true
|
||||
|
||||
override def packageAction = super.packageAction && webstartTask(this)
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.impl
|
||||
|
||||
import scala.util.parsing.combinator.Parsers
|
||||
import scala.util.parsing.input.CharSequenceReader
|
||||
import scala.util.parsing.input.CharArrayReader.EofCh
|
||||
|
||||
/** Parses a command of the form:
|
||||
* identifier argument*
|
||||
* where argument may be quoted to include spaces and
|
||||
* quotes and backslashes should be escaped.
|
||||
* (Most of the complexity is for decent error handling.)*/
|
||||
private[sbt] object CommandParser extends Parsers
|
||||
{
|
||||
type Elem = Char
|
||||
def parse(commandString: String): Either[String, (String, List[String])] =
|
||||
{
|
||||
command(new CharSequenceReader(commandString.trim, 0)) match
|
||||
{
|
||||
case Success(id ~ args, next) => Right((id, args))
|
||||
case err: NoSuccess =>
|
||||
{
|
||||
val pos = err.next.pos
|
||||
Left("Could not parse command: (" + pos.line + "," + pos.column + "): " + err.msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
def command = phrase(identifier ~! (argument*))
|
||||
def identifier = unquoted | err("Expected identifier")
|
||||
def argument = ( (whitespaceChar+) ~> (unquoted | quoted) )
|
||||
|
||||
def unquoted: Parser[String] = ((unquotedChar ~! (unquotedMainChar*)) ^^ { case a ~ tail => (a :: tail).mkString("") })
|
||||
def quoted: Parser[String] = quote ~> quotedChars <~ (quote | err("Missing closing quote character"))
|
||||
|
||||
def quotedChars: Parser[String] = (escape | nonescapeChar)*
|
||||
def escape: Parser[Char] = backslash ~> (escapeChar | err("Illegal escape"))
|
||||
def escapeChar: Parser[Char] = quote | backslash
|
||||
def nonescapeChar: Parser[Char] = elem("", ch => !isEscapeChar(ch) && ch != EofCh)
|
||||
def unquotedChar: Parser[Char] = elem("", ch => !isEscapeChar(ch) && !Character.isWhitespace(ch) && ch != EofCh)
|
||||
def unquotedMainChar: Parser[Char] = unquotedChar | (errorIfEscape ~> failure(""))
|
||||
|
||||
private def errorIfEscape = (not(quote) | err("Unexpected quote character")) ~>
|
||||
(not(backslash) | err("Escape sequences can only occur in a quoted argument"))
|
||||
|
||||
private def isEscapeChar(ch: Char) = ch == '\\' || ch == '"'
|
||||
|
||||
def quote: Parser[Char] = '"'
|
||||
def backslash: Parser[Char] = '\\'
|
||||
def whitespaceChar: Parser[Char] = elem("whitespace", ch => Character.isWhitespace(ch))
|
||||
|
||||
private implicit def toString(p: Parser[List[Char]]): Parser[String] = p ^^ {_ mkString "" }
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
|
||||
package sbt.impl
|
||||
|
||||
import java.util.Properties
|
||||
import java.io.{File, FileInputStream, FileOutputStream, InputStream, OutputStream}
|
||||
import scala.collection.mutable.{HashMap, HashSet, ListBuffer, Map, Set}
|
||||
|
||||
private[sbt] object PropertiesUtilities
|
||||
{
|
||||
def write(properties: Properties, label: String, to: Path, log: Logger) =
|
||||
FileUtilities.writeStream(to.asFile, log)(output => { properties.store(output, label); None })
|
||||
def load(properties: Properties, from: Path, log: Logger): Option[String] =
|
||||
{
|
||||
val file = from.asFile
|
||||
if(file.exists)
|
||||
FileUtilities.readStream(file, log)( input => { properties.load(input); None })
|
||||
else
|
||||
None
|
||||
}
|
||||
def propertyNames(properties: Properties): Iterable[String] =
|
||||
wrap.Wrappers.toList(properties.propertyNames).map(_.toString)
|
||||
}
|
||||
|
||||
private[sbt] object MapUtilities
|
||||
{
|
||||
def write[Key, Value](map: Map[Key, Value], label: String, to: Path, log: Logger)(implicit keyFormat: Format[Key], valueFormat: Format[Value]): Option[String] =
|
||||
{
|
||||
val properties = new Properties
|
||||
map foreach { pair => properties.setProperty(keyFormat.toString(pair._1), valueFormat.toString(pair._2)) }
|
||||
PropertiesUtilities.write(properties, label, to, log)
|
||||
}
|
||||
def read[Key, Value](map: Map[Key, Value], from: Path, log: Logger)(implicit keyFormat: Format[Key], valueFormat: Format[Value]): Option[String] =
|
||||
{
|
||||
map.clear
|
||||
val properties = new Properties
|
||||
PropertiesUtilities.load(properties, from, log) orElse
|
||||
{
|
||||
for(name <- PropertiesUtilities.propertyNames(properties))
|
||||
map.put( keyFormat.fromString(name), valueFormat.fromString(properties.getProperty(name)))
|
||||
None
|
||||
}
|
||||
}
|
||||
def all[Key, Value](map: Map[Key, Set[Value]]): Iterable[Value] =
|
||||
map.values.toList.flatMap(set => set.toList)
|
||||
|
||||
def readOnlyIterable[Key, Value](i: Map[Key, Set[Value]]): Iterable[(Key, scala.collection.Set[Value])] =
|
||||
for( (key, set) <- i.elements.toList) yield (key, wrap.Wrappers.readOnly(set))//.readOnly)
|
||||
|
||||
def mark[Key, Value](source: Key, map: Map[Key, Set[Value]])
|
||||
{
|
||||
if(!map.contains(source))
|
||||
map.put(source, new HashSet[Value])
|
||||
}
|
||||
def add[Key, Value](key: Key, value: Value, map: Map[Key, Set[Value]]): Unit =
|
||||
map.getOrElseUpdate(key, new HashSet[Value]) + value
|
||||
}
|
||||
|
|
@ -0,0 +1,353 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
import java.lang.{Process => JProcess, ProcessBuilder => JProcessBuilder}
|
||||
import java.io.{BufferedReader, Closeable, InputStream, InputStreamReader, IOException, OutputStream}
|
||||
import java.io.{PipedInputStream, PipedOutputStream}
|
||||
import java.io.{File, FileInputStream, FileOutputStream}
|
||||
import java.net.URL
|
||||
|
||||
import scala.concurrent.ops.future
|
||||
import scala.concurrent.SyncVar
|
||||
|
||||
/** Runs provided code in a new Thread and returns the Thread instance. */
|
||||
private object Spawn
|
||||
{
|
||||
def apply(f: => Unit): Thread =
|
||||
{
|
||||
val thread = new Thread() { override def run() = { f } }
|
||||
thread.start()
|
||||
thread
|
||||
}
|
||||
}
|
||||
|
||||
private object BasicIO
|
||||
{
|
||||
def apply(log: Logger) = new ProcessIO(ignoreOut, processFully(log, Level.Info), processFully(log, Level.Error))
|
||||
|
||||
def ignoreOut = (i: OutputStream) => ()
|
||||
val BufferSize = 8192
|
||||
def close(c: java.io.Closeable) = try { c.close() } catch { case _: java.io.IOException => () }
|
||||
def processFully(log: Logger, level: Level.Value)(i: InputStream) { processFully(line => log.log(level, line))(i) }
|
||||
def processFully(processLine: String => Unit)(i: InputStream)
|
||||
{
|
||||
val reader = new BufferedReader(new InputStreamReader(i))
|
||||
def readFully()
|
||||
{
|
||||
val line = reader.readLine()
|
||||
if(line != null)
|
||||
{
|
||||
processLine(line)
|
||||
readFully()
|
||||
}
|
||||
}
|
||||
readFully()
|
||||
}
|
||||
def standard: ProcessIO = new ProcessIO(ignoreOut, processFully(System.out.println), processFully(System.err.println))
|
||||
|
||||
def transferFully(in: InputStream, out: OutputStream)
|
||||
{
|
||||
val continueCount = 1//if(in.isInstanceOf[PipedInputStream]) 1 else 0
|
||||
val buffer = new Array[Byte](BufferSize)
|
||||
def read
|
||||
{
|
||||
val byteCount = in.read(buffer)
|
||||
if(byteCount >= continueCount)
|
||||
{
|
||||
out.write(buffer, 0, byteCount)
|
||||
read
|
||||
}
|
||||
}
|
||||
read
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private abstract class AbstractProcessBuilder extends ProcessBuilder
|
||||
{
|
||||
def #&&(other: ProcessBuilder): ProcessBuilder = new AndProcessBuilder(this, other)
|
||||
def #||(other: ProcessBuilder): ProcessBuilder = new OrProcessBuilder(this, other)
|
||||
def #|(other: ProcessBuilder): ProcessBuilder =
|
||||
{
|
||||
require(other.canPipeTo, "Piping to multiple processes is not supported.")
|
||||
new PipedProcessBuilder(this, other, false)
|
||||
}
|
||||
def ##(other: ProcessBuilder): ProcessBuilder = new SequenceProcessBuilder(this, other)
|
||||
|
||||
def #< (f: File): ProcessBuilder = new PipedProcessBuilder(new FileInput(f), this, false)
|
||||
def #< (url: URL): ProcessBuilder = new PipedProcessBuilder(new URLInput(url), this, false)
|
||||
def #> (f: File): ProcessBuilder = new PipedProcessBuilder(this, new FileOutput(f, false), false)
|
||||
def #>> (f: File): ProcessBuilder = new PipedProcessBuilder(this, new FileOutput(f, true), true)
|
||||
|
||||
def run(): Process = run(BasicIO.standard)
|
||||
def run(log: Logger): Process = run(BasicIO(log))
|
||||
|
||||
def ! = run().exitValue()
|
||||
def !(log: Logger) =
|
||||
{
|
||||
val log2 = new BufferedLogger(log)
|
||||
log2.startRecording()
|
||||
try { run(log2).exitValue() }
|
||||
finally { log2.playAll(); log2.clearAll() }
|
||||
}
|
||||
def !(io: ProcessIO) = run(io).exitValue()
|
||||
|
||||
def canPipeTo = false
|
||||
}
|
||||
private[sbt] class URLBuilder(url: URL) extends URLPartialBuilder
|
||||
{
|
||||
def #>(b: ProcessBuilder): ProcessBuilder = b #< url
|
||||
def #>>(file: File): ProcessBuilder = toFile(file, true)
|
||||
def #>(file: File): ProcessBuilder = toFile(file, false)
|
||||
private def toFile(file: File, append: Boolean) = new PipedProcessBuilder(new URLInput(url), new FileOutput(file, append), false)
|
||||
}
|
||||
private[sbt] class FileBuilder(base: File) extends FilePartialBuilder
|
||||
{
|
||||
def #>(b: ProcessBuilder): ProcessBuilder = b #< base
|
||||
def #<(b: ProcessBuilder): ProcessBuilder = b #> base
|
||||
def #<(url: URL): ProcessBuilder = new URLBuilder(url) #> base
|
||||
def #>>(file: File): ProcessBuilder = pipe(base, file, true)
|
||||
def #>(file: File): ProcessBuilder = pipe(base, file, false)
|
||||
def #<(file: File): ProcessBuilder = pipe(file, base, false)
|
||||
def #<<(file: File): ProcessBuilder = pipe(file, base, true)
|
||||
private def pipe(from: File, to: File, append: Boolean) = new PipedProcessBuilder(new FileInput(from), new FileOutput(to, append), false)
|
||||
}
|
||||
|
||||
private abstract class BasicBuilder extends AbstractProcessBuilder
|
||||
{
|
||||
protected[this] def checkNotThis(a: ProcessBuilder) = require(a != this, "Compound process '" + a + "' cannot contain itself.")
|
||||
final def run(io: ProcessIO): Process =
|
||||
{
|
||||
val p = createProcess(io)
|
||||
p.start()
|
||||
p
|
||||
}
|
||||
protected[this] def createProcess(io: ProcessIO): BasicProcess
|
||||
}
|
||||
private abstract class BasicProcess extends Process
|
||||
{
|
||||
def start(): Unit
|
||||
}
|
||||
|
||||
private abstract class CompoundProcess extends BasicProcess
|
||||
{
|
||||
def destroy() { destroyer() }
|
||||
def exitValue() = getExitValue().getOrElse(error("No exit code: process destroyed."))
|
||||
|
||||
def start() = getExitValue
|
||||
|
||||
protected lazy val (getExitValue, destroyer) =
|
||||
{
|
||||
val code = new SyncVar[Option[Int]]()
|
||||
code.set(None)
|
||||
val thread = Spawn(code.set(runAndExitValue()))
|
||||
|
||||
(
|
||||
future { thread.join(); code.get },
|
||||
() => thread.interrupt()
|
||||
)
|
||||
}
|
||||
|
||||
/** Start and block until the exit value is available and then return it in Some. Return None if destroyed (use 'run')*/
|
||||
protected[this] def runAndExitValue(): Option[Int]
|
||||
|
||||
protected[this] def runInterruptible[T](action: => T)(destroyImpl: => Unit): Option[T] =
|
||||
{
|
||||
try { Some(action) }
|
||||
catch { case _: InterruptedException => destroyImpl; None }
|
||||
}
|
||||
}
|
||||
|
||||
private abstract class SequentialProcessBuilder(a: ProcessBuilder, b: ProcessBuilder, operatorString: String) extends BasicBuilder
|
||||
{
|
||||
checkNotThis(a)
|
||||
checkNotThis(b)
|
||||
override def toString = " ( " + a + " " + operatorString + " " + b + " ) "
|
||||
}
|
||||
private class PipedProcessBuilder(first: ProcessBuilder, second: ProcessBuilder, toError: Boolean) extends SequentialProcessBuilder(first, second, if(toError) "#|!" else "#|")
|
||||
{
|
||||
override def createProcess(io: ProcessIO) = new PipedProcesses(first, second, io, toError)
|
||||
}
|
||||
private class AndProcessBuilder(first: ProcessBuilder, second: ProcessBuilder) extends SequentialProcessBuilder(first, second, "#&&")
|
||||
{
|
||||
override def createProcess(io: ProcessIO) = new AndProcess(first, second, io)
|
||||
}
|
||||
private class OrProcessBuilder(first: ProcessBuilder, second: ProcessBuilder) extends SequentialProcessBuilder(first, second, "#||")
|
||||
{
|
||||
override def createProcess(io: ProcessIO) = new OrProcess(first, second, io)
|
||||
}
|
||||
private class SequenceProcessBuilder(first: ProcessBuilder, second: ProcessBuilder) extends SequentialProcessBuilder(first, second, "##")
|
||||
{
|
||||
override def createProcess(io: ProcessIO) = new ProcessSequence(first, second, io)
|
||||
}
|
||||
|
||||
private class SequentialProcess(a: ProcessBuilder, b: ProcessBuilder, io: ProcessIO, evaluateSecondProcess: Int => Boolean) extends CompoundProcess
|
||||
{
|
||||
protected[this] override def runAndExitValue() =
|
||||
{
|
||||
val first = a.run(io)
|
||||
runInterruptible(first.exitValue)(first.destroy()) flatMap
|
||||
{ codeA =>
|
||||
if(evaluateSecondProcess(codeA))
|
||||
{
|
||||
val second = b.run(io)
|
||||
runInterruptible(second.exitValue)(second.destroy())
|
||||
}
|
||||
else
|
||||
Some(codeA)
|
||||
}
|
||||
}
|
||||
}
|
||||
private class AndProcess(a: ProcessBuilder, b: ProcessBuilder, io: ProcessIO) extends SequentialProcess(a, b, io, _ == 0)
|
||||
private class OrProcess(a: ProcessBuilder, b: ProcessBuilder, io: ProcessIO) extends SequentialProcess(a, b, io, _ != 0)
|
||||
private class ProcessSequence(a: ProcessBuilder, b: ProcessBuilder, io: ProcessIO) extends SequentialProcess(a, b, io, ignore => true)
|
||||
|
||||
|
||||
private class PipedProcesses(a: ProcessBuilder, b: ProcessBuilder, defaultIO: ProcessIO, toError: Boolean) extends CompoundProcess
|
||||
{
|
||||
protected[this] override def runAndExitValue() =
|
||||
{
|
||||
val currentSource = new SyncVar[Option[InputStream]]
|
||||
val pipeOut = new PipedOutputStream
|
||||
val source = new PipeSource(currentSource, pipeOut, a.toString)
|
||||
source.start()
|
||||
|
||||
val pipeIn = new PipedInputStream(pipeOut)
|
||||
val currentSink = new SyncVar[Option[OutputStream]]
|
||||
val sink = new PipeSink(pipeIn, currentSink, b.toString)
|
||||
sink.start()
|
||||
|
||||
def handleOutOrError(fromOutput: InputStream) = currentSource.put(Some(fromOutput))
|
||||
|
||||
val firstIO =
|
||||
if(toError)
|
||||
defaultIO.withError(handleOutOrError)
|
||||
else
|
||||
defaultIO.withOutput(handleOutOrError)
|
||||
val secondIO = defaultIO.withInput(toInput => currentSink.put(Some(toInput)) )
|
||||
|
||||
val second = b.run(secondIO)
|
||||
val first = a.run(firstIO)
|
||||
try
|
||||
{
|
||||
runInterruptible {
|
||||
first.exitValue
|
||||
currentSource.put(None)
|
||||
currentSink.put(None)
|
||||
val result = second.exitValue
|
||||
result
|
||||
} {
|
||||
first.destroy()
|
||||
second.destroy()
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
BasicIO.close(pipeIn)
|
||||
BasicIO.close(pipeOut)
|
||||
}
|
||||
}
|
||||
}
|
||||
private class PipeSource(currentSource: SyncVar[Option[InputStream]], pipe: PipedOutputStream, label: => String) extends Thread
|
||||
{
|
||||
final override def run()
|
||||
{
|
||||
currentSource.get match
|
||||
{
|
||||
case Some(source) =>
|
||||
try { BasicIO.transferFully(source, pipe) }
|
||||
catch { case e: IOException => println("I/O error " + e.getMessage + " for process: " + label); e.printStackTrace() }
|
||||
finally
|
||||
{
|
||||
BasicIO.close(source)
|
||||
currentSource.unset()
|
||||
}
|
||||
run()
|
||||
case None =>
|
||||
currentSource.unset()
|
||||
BasicIO.close(pipe)
|
||||
}
|
||||
}
|
||||
}
|
||||
private class PipeSink(pipe: PipedInputStream, currentSink: SyncVar[Option[OutputStream]], label: => String) extends Thread
|
||||
{
|
||||
final override def run()
|
||||
{
|
||||
currentSink.get match
|
||||
{
|
||||
case Some(sink) =>
|
||||
try { BasicIO.transferFully(pipe, sink) }
|
||||
catch { case e: IOException => println("I/O error " + e.getMessage + " for process: " + label); e.printStackTrace() }
|
||||
finally
|
||||
{
|
||||
BasicIO.close(sink)
|
||||
currentSink.unset()
|
||||
}
|
||||
run()
|
||||
case None =>
|
||||
currentSink.unset()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** Represents a simple command without any redirection or combination. */
|
||||
private[sbt] class SimpleProcessBuilder(p: JProcessBuilder) extends AbstractProcessBuilder
|
||||
{
|
||||
override def run(io: ProcessIO): Process =
|
||||
{
|
||||
val process = p.start() // start the external process
|
||||
import io.{writeInput, processOutput, processError}
|
||||
// spawn threads that process the input, output, and error streams using the functions defined in `io`
|
||||
val inThread = Spawn(writeInput(process.getOutputStream))
|
||||
val outThread = Spawn(processOutput(process.getInputStream))
|
||||
val errorThread =
|
||||
if(!p.redirectErrorStream)
|
||||
Spawn(processError(process.getErrorStream)) :: Nil
|
||||
else
|
||||
Nil
|
||||
new SimpleProcess(process, inThread :: outThread :: errorThread)
|
||||
}
|
||||
override def toString = p.command.toString
|
||||
override def canPipeTo = true
|
||||
}
|
||||
/** A thin wrapper around a java.lang.Process. `ioThreads` are the Threads created to do I/O.
|
||||
* The implementation of `exitValue` waits until these threads die before returning. */
|
||||
private class SimpleProcess(p: JProcess, ioThreads: Iterable[Thread]) extends Process
|
||||
{
|
||||
override def exitValue() =
|
||||
{
|
||||
p.waitFor() // wait for the process to terminate
|
||||
ioThreads.foreach(_.join()) // this ensures that all output is complete before returning (waitFor does not ensure this)
|
||||
p.exitValue()
|
||||
}
|
||||
override def destroy() = p.destroy()
|
||||
}
|
||||
|
||||
private class FileOutput(file: File, append: Boolean) extends OutputStreamBuilder(new FileOutputStream(file, append), file.getAbsolutePath)
|
||||
private class URLInput(url: URL) extends InputStreamBuilder(url.openStream, url.toString)
|
||||
private class FileInput(file: File) extends InputStreamBuilder(new FileInputStream(file), file.getAbsolutePath)
|
||||
|
||||
private class OutputStreamBuilder(stream: => OutputStream, label: String) extends ThreadProcessBuilder(label, _.writeInput(stream))
|
||||
private class InputStreamBuilder(stream: => InputStream, label: String) extends ThreadProcessBuilder(label, _.processOutput(stream))
|
||||
|
||||
private abstract class ThreadProcessBuilder(override val toString: String, runImpl: ProcessIO => Unit) extends AbstractProcessBuilder
|
||||
{
|
||||
override def run(io: ProcessIO): Process =
|
||||
{
|
||||
val success = new SyncVar[Boolean]
|
||||
success.put(false)
|
||||
new ThreadProcess(Spawn {runImpl(io); success.set(true) }, success)
|
||||
}
|
||||
}
|
||||
private class ThreadProcess(thread: Thread, success: SyncVar[Boolean]) extends Process
|
||||
{
|
||||
override def exitValue() =
|
||||
{
|
||||
thread.join()
|
||||
if(success.get) 0 else 1
|
||||
}
|
||||
override def destroy() { thread.interrupt() }
|
||||
}
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.impl
|
||||
|
||||
import scala.collection.{immutable, mutable}
|
||||
import scala.collection.Map
|
||||
import sbt.wrap.Wrappers.identityMap
|
||||
|
||||
private[sbt] object RunTask
|
||||
{
|
||||
final type Task = Project#Task
|
||||
def apply(root: Task, rootName: String): List[WorkFailure[Task]] = apply(root, rootName, true)
|
||||
def apply(root: Task, rootName: String, parallelExecution: Boolean): List[WorkFailure[Task]] =
|
||||
apply(root, rootName, if(parallelExecution) Runtime.getRuntime.availableProcessors else 1)
|
||||
def apply(root: Task, rootName: String, maximumTasks: Int): List[WorkFailure[Task]] = (new RunTask(root, rootName, maximumTasks)).run()
|
||||
}
|
||||
import RunTask._
|
||||
private final class RunTask(root: Task, rootName: String, maximumTasks: Int) extends NotNull
|
||||
{
|
||||
require(maximumTasks >= 1)
|
||||
def parallel = maximumTasks > 1
|
||||
def multiProject = allProjects.size >= 2
|
||||
def run(): List[WorkFailure[Task]] =
|
||||
{
|
||||
try
|
||||
{
|
||||
runTasksExceptRoot() match
|
||||
{
|
||||
case Nil =>
|
||||
val result = runTask(root, rootName)
|
||||
result.map( errorMessage => WorkFailure(root, "Error running " + rootName + ": " + errorMessage) ).toList
|
||||
case failures => failures
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
for(project <- allProjects; saveError <- project.saveEnvironment)
|
||||
project.log.warn("Could not save properties for project " + project.name + ": " + saveError)
|
||||
}
|
||||
}
|
||||
// This runs all tasks except the root.task.
|
||||
// It uses a buffered logger in record mode to ensure that all output for a given task is consecutive
|
||||
// it ignores the root task so that the root task may be run with buffering disabled so that the output
|
||||
// occurs without delay.
|
||||
private def runTasksExceptRoot() =
|
||||
{
|
||||
withBuffered(_.startRecording())
|
||||
try { ParallelRunner.run(expandedRoot, expandedTaskName, runIfNotRoot, maximumTasks, (t: Task) => t.manager.log) }
|
||||
finally { withBuffered(_.stop()) }
|
||||
}
|
||||
private def withBuffered(f: BufferedLogger => Unit)
|
||||
{
|
||||
for(buffered <- bufferedLoggers)
|
||||
Control.trap(f(buffered))
|
||||
}
|
||||
/** Will be called in its own thread. Runs the given task if it is not the root task.*/
|
||||
private def runIfNotRoot(action: Task): Option[String] =
|
||||
{
|
||||
if(isRoot(action))
|
||||
None
|
||||
else
|
||||
runTask(action, expandedTaskName(action))
|
||||
}
|
||||
private def isRoot(t: Task) = t == expandedRoot
|
||||
/** Will be called in its own thread except for the root task. */
|
||||
private def runTask(action: Task, actionName: String): Option[String] =
|
||||
{
|
||||
val label = if(multiProject) (action.manager.name + " / " + actionName) else actionName
|
||||
def banner(event: ControlEvent.Value, firstSeparator: String, secondSeparator: String) =
|
||||
Control.trap(action.manager.log.control(event, firstSeparator + " " + label + " " + secondSeparator))
|
||||
if(parallel)
|
||||
{
|
||||
try { banner(ControlEvent.Start, "\n ", "...") }
|
||||
finally { flush(action) }
|
||||
}
|
||||
banner(ControlEvent.Header, "\n==", "==")
|
||||
try { action.invoke }
|
||||
catch { case e: Exception => action.manager.log.trace(e); Some(e.toString) }
|
||||
finally
|
||||
{
|
||||
banner(ControlEvent.Finish, "==", "==")
|
||||
if(parallel)
|
||||
flush(action)
|
||||
}
|
||||
}
|
||||
private def trapFinally(toTrap: => Unit)(runFinally: => Unit)
|
||||
{
|
||||
try { toTrap }
|
||||
catch { case e: Exception => () }
|
||||
finally { try { runFinally } catch { case e: Exception => () } }
|
||||
}
|
||||
private def flush(action: Task)
|
||||
{
|
||||
for(buffered <- bufferedLogger(action.manager))
|
||||
Control.trap(flush(buffered))
|
||||
}
|
||||
private def flush(buffered: BufferedLogger)
|
||||
{
|
||||
buffered.play()
|
||||
buffered.clear()
|
||||
}
|
||||
|
||||
/* Most of the following is for implicitly adding dependencies (see the expand method)*/
|
||||
private val projectDependencyCache = identityMap[Project, Iterable[Project]]
|
||||
private def dependencies(project: Project) = projectDependencyCache.getOrElseUpdate(project, project.topologicalSort.dropRight(1))
|
||||
|
||||
private val expandedCache = identityMap[Task, Task]
|
||||
private def expanded(task: Task): Task = expandedCache.getOrElseUpdate(task, expandImpl(task))
|
||||
|
||||
private val expandedTaskNameCache = identityMap[Task, String]
|
||||
private def expandedTaskName(task: Task) =
|
||||
if(task == expandedRoot)
|
||||
rootName
|
||||
else
|
||||
expandedTaskNameCache.getOrElse(task, task.name)
|
||||
|
||||
private val nameToTaskCache = identityMap[Project, Map[String, Task]]
|
||||
private def nameToTaskMap(project: Project): Map[String, Task] = nameToTaskCache.getOrElseUpdate(project, project.tasks)
|
||||
private def taskForName(project: Project, name: String): Option[Task] = nameToTaskMap(project).get(name)
|
||||
|
||||
private val taskNameCache = identityMap[Project, Map[Task, String]]
|
||||
private def taskName(task: Task) =
|
||||
{
|
||||
val project = task.manager
|
||||
taskNameCache.getOrElseUpdate(project, taskNameMap(project)).get(task)
|
||||
}
|
||||
|
||||
private val expandedRoot = expand(root)
|
||||
private val allTasks = expandedRoot.topologicalSort
|
||||
private val allProjects = Set(allTasks.map(_.manager).toSeq : _*)
|
||||
private val bufferedLoggers = if(parallel) allProjects.toList.flatMap(bufferedLogger) else Nil
|
||||
|
||||
/** Adds implicit dependencies, which are tasks with the same name in the project dependencies
|
||||
* of the enclosing project of the task.*/
|
||||
private def expand(root: Task): Task = expanded(root)
|
||||
private def expandImpl(task: Task): Task =
|
||||
{
|
||||
val nameOption = taskName(task)
|
||||
val explicitDependencies = task.dependencies
|
||||
val implicitDependencies = nameOption.map(name => dependencies(task.manager).flatMap(noninteractiveTask(name)) ).getOrElse(Nil)
|
||||
val allDependencies = mutable.HashSet( (explicitDependencies ++ implicitDependencies).toSeq : _* )
|
||||
val expandedTask = task.setDependencies(allDependencies.toList.map(expanded))
|
||||
nameOption.foreach(name => expandedTaskNameCache(expandedTask) = name)
|
||||
expandedTask
|
||||
}
|
||||
private def noninteractiveTask(name: String)(project: Project): Option[Task] =
|
||||
taskForName(project, name) flatMap { task =>
|
||||
if(task.interactive)
|
||||
{
|
||||
project.log.debug("Not including task " + name + " in project " + project.name + ": interactive tasks can only be run directly.")
|
||||
None
|
||||
}
|
||||
else
|
||||
Some(task)
|
||||
}
|
||||
private def taskNameMap(project: Project) = mutable.Map(nameToTaskMap(project).map(_.swap).toSeq : _*)
|
||||
private def bufferedLogger(project: Project): Option[BufferedLogger] =
|
||||
project.log match
|
||||
{
|
||||
case buffered: BufferedLogger => Some(buffered)
|
||||
case _ => None
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
package sbt.impl
|
||||
|
||||
private[sbt] object SelectMainClass
|
||||
{
|
||||
def apply(promptIfMultipleChoices: Boolean, mainClasses: List[String]) =
|
||||
{
|
||||
mainClasses match
|
||||
{
|
||||
case Nil => None
|
||||
case head :: Nil => Some(head)
|
||||
case multiple =>
|
||||
if(promptIfMultipleChoices)
|
||||
{
|
||||
println("\nMultiple main classes detected, select one to run:\n")
|
||||
for( (className, index) <- multiple.zipWithIndex )
|
||||
println(" [" + (index+1) + "] " + className)
|
||||
val line = trim(SimpleReader.readLine("\nEnter number: "))
|
||||
println("")
|
||||
toInt(line, multiple.length) map multiple.apply
|
||||
}
|
||||
else
|
||||
None
|
||||
}
|
||||
}
|
||||
private def trim(s: Option[String]) = s.getOrElse("")
|
||||
private def toInt(s: String, size: Int) =
|
||||
try
|
||||
{
|
||||
val i = s.toInt
|
||||
if(i > 0 && i <= size)
|
||||
Some(i-1)
|
||||
else
|
||||
{
|
||||
println("Number out of range: was " + i + ", expected number between 1 and " + size)
|
||||
None
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
case nfe: NumberFormatException =>
|
||||
println("Invalid number: " + nfe.toString)
|
||||
None
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,186 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Steven Blundy, Mark Harrah
|
||||
*/
|
||||
|
||||
package sbt.impl
|
||||
|
||||
import scala.xml.{Elem, Group}
|
||||
|
||||
/* The following classes run tests for their associated test framework.
|
||||
* NOTE #1: DO NOT actively use these classes. Only specify their names to LazyTestFramework
|
||||
* for reflective loading. This allows using the test libraries provided on the
|
||||
* project classpath instead of requiring global versions.
|
||||
* NOTE #2: Keep all active uses of these test frameworks inside these classes so that sbt
|
||||
* runs without error when a framework is not available at runtime and no tests for that
|
||||
* framework are defined.*/
|
||||
|
||||
/** The test runner for ScalaCheck tests. */
|
||||
private[sbt] class ScalaCheckRunner(val log: Logger, val listeners: Seq[TestReportListener], val testLoader: ClassLoader) extends BasicTestRunner
|
||||
{
|
||||
import org.scalacheck.{Pretty, Properties, Test}
|
||||
def runTest(testClassName: String): Result.Value =
|
||||
{
|
||||
val test = ModuleUtilities.getObject(testClassName, testLoader).asInstanceOf[Properties]
|
||||
if(Test.checkProperties(test, Test.defaultParams, propReport, testReport).find(!_._2.passed).isEmpty)
|
||||
Result.Passed
|
||||
else
|
||||
Result.Failed
|
||||
}
|
||||
private def propReport(pName: String, s: Int, d: Int) {}
|
||||
private def testReport(pName: String, res: Test.Result) =
|
||||
{
|
||||
if(res.passed)
|
||||
fire(PassedEvent(pName, Pretty.pretty(res)))
|
||||
else
|
||||
fire(FailedEvent(pName, Pretty.pretty(res)))
|
||||
}
|
||||
}
|
||||
/** The test runner for ScalaTest suites. */
|
||||
private[sbt] class ScalaTestRunner(val log: Logger, val listeners: Seq[TestReportListener], val testLoader: ClassLoader) extends BasicTestRunner
|
||||
{
|
||||
def runTest(testClassName: String): Result.Value =
|
||||
{
|
||||
import org.scalatest.{Stopper, Suite}
|
||||
val testClass = Class.forName(testClassName, true, testLoader).asSubclass(classOf[Suite])
|
||||
val test = testClass.newInstance
|
||||
val reporter = new ScalaTestReporter
|
||||
val stopper = new Stopper { override def stopRequested = false }
|
||||
test.execute(None, reporter, stopper, Set.empty, Set("org.scalatest.Ignore"), Map.empty, None)
|
||||
if(reporter.succeeded)
|
||||
Result.Passed
|
||||
else
|
||||
Result.Failed
|
||||
}
|
||||
|
||||
/** An implementation of Reporter for ScalaTest. */
|
||||
private class ScalaTestReporter extends org.scalatest.Reporter with NotNull
|
||||
{
|
||||
import org.scalatest.Report
|
||||
override def testIgnored(report: Report) =
|
||||
{
|
||||
if(report.message.trim.isEmpty) fire(IgnoredEvent(report.name, None))
|
||||
else fire(IgnoredEvent(report.name, Some(report.message.trim)))
|
||||
}
|
||||
override def testStarting(report: Report) { info(report, "Test starting", None) }
|
||||
override def testSucceeded(report: Report) { info(report, "Test succeeded", Some(Result.Passed)) }
|
||||
override def testFailed(report: Report)
|
||||
{
|
||||
succeeded = false
|
||||
error(report, "Test failed", Some(Result.Failed))
|
||||
}
|
||||
|
||||
override def infoProvided(report : Report) { info(report, "", None) }
|
||||
|
||||
override def suiteStarting(report: Report) { info(report, "Suite starting", None) }
|
||||
override def suiteCompleted(report: Report) { info(report, "Suite completed", None) }
|
||||
override def suiteAborted(report: Report) { error(report, "Suite aborted", None) }
|
||||
|
||||
override def runStarting(testCount: Int) { fire(MessageEvent("Run starting")) }
|
||||
override def runStopped()
|
||||
{
|
||||
succeeded = false
|
||||
fire(ErrorEvent("Run stopped"))
|
||||
}
|
||||
override def runAborted(report: Report)
|
||||
{
|
||||
succeeded = false
|
||||
error(report, "Run aborted", None)
|
||||
}
|
||||
override def runCompleted() { log.info("Run completed.") }
|
||||
|
||||
private def error(report: Report, event: String, result: Option[Result.Value]) { logReport(report, event, result, Level.Error) }
|
||||
private def info(report: Report, event: String, result: Option[Result.Value]) { logReport(report, event, result, Level.Info) }
|
||||
private def logReport(report: Report, event: String, result: Option[Result.Value], level: Level.Value)
|
||||
{
|
||||
level match
|
||||
{
|
||||
case Level.Error =>
|
||||
if(report.message.trim.isEmpty)
|
||||
fire(TypedErrorEvent(report.name, event, None, report.throwable)(result))
|
||||
else
|
||||
fire(TypedErrorEvent(report.name, event, Some(report.message.trim), report.throwable)(result))
|
||||
case Level.Info =>
|
||||
if(report.message.trim.isEmpty)
|
||||
fire(TypedEvent(report.name, event, None)(result))
|
||||
else
|
||||
fire(TypedEvent(report.name, event, Some(report.message.trim))(result))
|
||||
case l => log.warn("Level not expected:" + l)
|
||||
}
|
||||
}
|
||||
|
||||
var succeeded = true
|
||||
}
|
||||
}
|
||||
/** The test runner for specs tests. */
|
||||
private[sbt] class SpecsRunner(val log: Logger, val listeners: Seq[TestReportListener], val testLoader: ClassLoader) extends BasicTestRunner
|
||||
{
|
||||
import org.specs.Specification
|
||||
import org.specs.specification.{Example, Sus}
|
||||
|
||||
def runTest(testClassName: String): Result.Value =
|
||||
{
|
||||
val test = ModuleUtilities.getObject(testClassName, testLoader).asInstanceOf[Specification]
|
||||
val event = reportSpecification(test)
|
||||
fire(event)
|
||||
if(test.isFailing)
|
||||
Result.Failed
|
||||
else
|
||||
Result.Passed
|
||||
}
|
||||
|
||||
/* The following is closely based on org.specs.runner.OutputReporter,
|
||||
* part of specs, which is Copyright 2007-2008 Eric Torreborre.
|
||||
* */
|
||||
|
||||
private def reportSpecification(spec: Specification): SpecificationReportEvent =
|
||||
{
|
||||
// this is for binary compatibility between specs 1.4.x and 1.5.0: the ancestor of Specification containing these two methods changed
|
||||
val reflectedSpec: { def systems: Seq[Sus]; def subSpecifications: Seq[Specification] } = spec
|
||||
|
||||
return SpecificationReportEvent(spec.successes.size, spec.failures.size, spec.errors.size, spec.skipped.size, spec.pretty,
|
||||
reportSystems(reflectedSpec.systems), reportSpecifications(reflectedSpec.subSpecifications))
|
||||
}
|
||||
private def reportSpecifications(specifications: Seq[Specification]): Seq[SpecificationReportEvent] =
|
||||
{
|
||||
for(specification <- specifications) yield
|
||||
reportSpecification(specification)
|
||||
}
|
||||
private def reportSystems(systems: Seq[Sus]): Seq[SystemReportEvent] =
|
||||
{
|
||||
for(system <- systems) yield
|
||||
reportSystem(system)
|
||||
}
|
||||
private def reportSystem(sus: Sus): SystemReportEvent =
|
||||
{
|
||||
def format =
|
||||
{
|
||||
class ElemDesc(e: Elem) { def desc = e.child }
|
||||
implicit def elemToDesc(e: Elem): ElemDesc = new ElemDesc(e)
|
||||
|
||||
for(description <- sus.literateDescription) yield
|
||||
{
|
||||
// for source compatibility between specs 1.4.x and 1.5.0:
|
||||
// in specs 1.5.0, description is LiterateDescription
|
||||
// in specs < 1.5.0, description is Elem
|
||||
// LiterateDescription.desc is a Node
|
||||
// Elem.child is a Seq[Node]
|
||||
// each has a map[T](f: Node => T): Seq[T] defined so we implicitly convert
|
||||
// an Elem e to an intermediate object that has desc defined to be e.child
|
||||
|
||||
//description.child.map(_.text) // Elem equivalent
|
||||
description.desc.map(_.text) // LiterateDescription
|
||||
}
|
||||
}
|
||||
|
||||
SystemReportEvent(sus.description, sus.verb, sus.skippedSus, format, reportExamples(sus.examples))
|
||||
}
|
||||
private def reportExamples(examples: Seq[Example]): Seq[ExampleReportEvent] =
|
||||
{
|
||||
for(example <- examples) yield
|
||||
reportExample(example)
|
||||
}
|
||||
private def reportExample(example: Example): ExampleReportEvent =
|
||||
{
|
||||
ExampleReportEvent(example.description, example.errors, example.failures, example.skipped, reportExamples(example.subExamples))
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2008, 2009 Mark Harrah
|
||||
*/
|
||||
package sbt
|
||||
|
||||
/* The following implements the simple syntax for storing test definitions.
|
||||
* The syntax is:
|
||||
*
|
||||
* definition := isModule? className separator className
|
||||
* isModule := '<module>'
|
||||
* separator := '<<'
|
||||
*/
|
||||
|
||||
import scala.util.parsing.combinator._
|
||||
|
||||
import TestParser._
|
||||
/** Represents a test implemented by 'testClassName' of type 'superClassName'.*/
|
||||
final case class TestDefinition(isModule: Boolean, testClassName: String, superClassName: String) extends NotNull
|
||||
{
|
||||
override def toString =
|
||||
(if(isModule) IsModuleLiteral else "") + testClassName + SubSuperSeparator + superClassName
|
||||
}
|
||||
final class TestParser extends RegexParsers with NotNull
|
||||
{
|
||||
def test: Parser[TestDefinition] =
|
||||
( isModule ~! className ~! SubSuperSeparator ~! className ) ^^
|
||||
{ case module ~ testName ~ SubSuperSeparator ~ superName => TestDefinition(module, testName.trim, superName.trim) }
|
||||
def isModule: Parser[Boolean] = (IsModuleLiteral?) ^^ (_.isDefined)
|
||||
def className: Parser[String] = ClassNameRegexString.r
|
||||
|
||||
def parse(testDefinitionString: String): Either[String, TestDefinition] =
|
||||
{
|
||||
def parseError(msg: String) = Left("Could not parse test definition '" + testDefinitionString + "': " + msg)
|
||||
parseAll(test, testDefinitionString) match
|
||||
{
|
||||
case Success(result, next) => Right(result)
|
||||
case err: NoSuccess => parseError(err.msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
object TestParser
|
||||
{
|
||||
val IsModuleLiteral = "<module>"
|
||||
val SubSuperSeparator = "<<"
|
||||
val ClassNameRegexString = """[^<]+"""
|
||||
def parse(testDefinitionString: String): Either[String, TestDefinition] = (new TestParser).parse(testDefinitionString)
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.impl
|
||||
|
||||
import java.io.File
|
||||
import scala.collection.mutable.{HashMap, Map}
|
||||
|
||||
/** Only intended to be used once per instance. */
|
||||
private[sbt] class TestStatusReporter(path: Path, log: Logger) extends TestsListener
|
||||
{
|
||||
private lazy val succeeded: Map[String, Long] = TestStatus.read(path, log)
|
||||
|
||||
def doInit {}
|
||||
def startGroup(name: String) { succeeded removeKey name }
|
||||
def testEvent(event: TestEvent) {}
|
||||
def endGroup(name: String, t: Throwable) {}
|
||||
def endGroup(name: String, result: Result.Value)
|
||||
{
|
||||
if(result == Result.Passed)
|
||||
succeeded(name) = System.currentTimeMillis
|
||||
}
|
||||
def doComplete(finalResult: Result.Value) { complete() }
|
||||
def doComplete(t: Throwable) { complete() }
|
||||
|
||||
private def complete()
|
||||
{
|
||||
TestStatus.write(succeeded, "Successful Tests", path, log)
|
||||
}
|
||||
}
|
||||
|
||||
private[sbt] class TestQuickFilter(testAnalysis: CompileAnalysis, failedOnly: Boolean, path: Path, log: Logger) extends (String => Boolean) with NotNull
|
||||
{
|
||||
private lazy val exclude = TestStatus.read(path, log)
|
||||
private lazy val map = testAnalysis.testSourceMap
|
||||
def apply(test: String) =
|
||||
exclude.get(test) match
|
||||
{
|
||||
case None => true // include because this test has not been run or did not succeed
|
||||
case Some(lastSuccessTime) => // succeeded the last time it was run
|
||||
if(failedOnly)
|
||||
false // don't include because the last time succeeded
|
||||
else
|
||||
testAnalysis.products(map(test)) match
|
||||
{
|
||||
case None => true
|
||||
case Some(products) => products.exists(lastSuccessTime <= _.lastModified) // include if the test is newer than the last run
|
||||
}
|
||||
}
|
||||
}
|
||||
private object TestStatus
|
||||
{
|
||||
import java.util.Properties
|
||||
def read(path: Path, log: Logger): Map[String, Long] =
|
||||
{
|
||||
val map = new HashMap[String, Long]
|
||||
val properties = new Properties
|
||||
logError(PropertiesUtilities.load(properties, path, log), "loading", log)
|
||||
for(test <- PropertiesUtilities.propertyNames(properties))
|
||||
map.put(test, properties.getProperty(test).toLong)
|
||||
map
|
||||
}
|
||||
def write(map: Map[String, Long], label: String, path: Path, log: Logger)
|
||||
{
|
||||
val properties = new Properties
|
||||
for( (test, lastSuccessTime) <- map)
|
||||
properties.setProperty(test, lastSuccessTime.toString)
|
||||
logError(PropertiesUtilities.write(properties, label, path, log), "writing", log)
|
||||
}
|
||||
private def logError(result: Option[String], action: String, log: Logger)
|
||||
{
|
||||
result.foreach(msg => log.error("Error " + action + " test status: " + msg))
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
/* sbt -- Simple Build Tool
|
||||
* Copyright 2009 Mark Harrah
|
||||
*/
|
||||
package sbt.wrap
|
||||
|
||||
// This file exists for compatibility between Scala 2.7.x and 2.8.0
|
||||
|
||||
import java.util.{Map => JMap, Set => JSet}
|
||||
|
||||
private[sbt] object Wrappers
|
||||
{
|
||||
def identityMap[K,V] = new MutableMapWrapper(new java.util.IdentityHashMap[K,V])
|
||||
def weakMap[K,V] = new MutableMapWrapper(new java.util.WeakHashMap[K,V])
|
||||
def toList[K,V](s: java.util.Map[K,V]): List[(K,V)] = toList(s.entrySet).map(e => (e.getKey, e.getValue))
|
||||
def toList[T](s: java.util.Collection[T]): List[T] = toList(s.iterator)
|
||||
def toList[T](s: java.util.Iterator[T]): List[T] =
|
||||
{
|
||||
def add(l: List[T]): List[T] =
|
||||
if(s.hasNext)
|
||||
add(s.next() :: l)
|
||||
else
|
||||
l
|
||||
add(Nil).reverse
|
||||
}
|
||||
def toList[T](s: java.util.Enumeration[T]): List[T] =
|
||||
{
|
||||
def add(l: List[T]): List[T] =
|
||||
if(s.hasMoreElements)
|
||||
add(s.nextElement() :: l)
|
||||
else
|
||||
l
|
||||
add(Nil).reverse
|
||||
}
|
||||
def readOnly[K,V](map: scala.collection.mutable.Map[K,V]): scala.collection.Map[K,V] = map//.readOnly
|
||||
def readOnly[T](set: scala.collection.mutable.Set[T]): scala.collection.Set[T] = set//.readOnly
|
||||
def readOnly[T](buffer: scala.collection.mutable.Buffer[T]): Seq[T] = buffer//.readOnly
|
||||
}
|
||||
|
||||
private[sbt] sealed abstract class Iterable[T] extends NotNull
|
||||
{
|
||||
def foreach(f: T => Unit) = toList.foreach(f)
|
||||
def toList: List[T]
|
||||
}
|
||||
private[sbt] sealed trait Removable[T] extends NotNull
|
||||
{
|
||||
def -=(t: T) : Unit
|
||||
def --=(all: Iterable[T]) { all.foreach(-=) }
|
||||
def --=(all: scala.Iterable[T]) { all.foreach(-=) }
|
||||
}
|
||||
private[sbt] sealed trait Addable[T] extends NotNull
|
||||
{
|
||||
def +=(t: T) : Unit
|
||||
def ++=(all: Iterable[T]) { all.foreach(+=) }
|
||||
def ++=(all: scala.Iterable[T]) { all.foreach(+=) }
|
||||
}
|
||||
private[sbt] sealed abstract class Set[T] extends Iterable[T]
|
||||
{
|
||||
def contains(t: T): Boolean
|
||||
}
|
||||
private[sbt] sealed class SetWrapper[T](val underlying: JSet[T]) extends Set[T]
|
||||
{
|
||||
def contains(t: T) = underlying.contains(t)
|
||||
def toList =Wrappers.toList(underlying.iterator)
|
||||
}
|
||||
private[sbt] final class MutableSetWrapper[T](wrapped: JSet[T]) extends SetWrapper[T](wrapped) with Addable[T] with Removable[T]
|
||||
{
|
||||
def +=(t: T) { underlying.add(t) }
|
||||
def -=(t: T) { underlying.remove(t) }
|
||||
def readOnly: Set[T] = this
|
||||
}
|
||||
private[sbt] sealed abstract class Map[K,V] extends Iterable[(K,V)]
|
||||
{
|
||||
def apply(key: K): V
|
||||
def get(key: K): Option[V]
|
||||
final def getOrElse[V2 >: V](key: K, default: => V2): V2 =
|
||||
get(key) match
|
||||
{
|
||||
case Some(value) => value
|
||||
case None => default
|
||||
}
|
||||
}
|
||||
private[sbt] sealed abstract class MapWrapper[K,V](val underlying: JMap[K,V]) extends Map[K,V]
|
||||
{
|
||||
final def apply(key: K) = underlying.get(key)
|
||||
final def get(key: K) =
|
||||
{
|
||||
val value = underlying.get(key)
|
||||
if(value == null)
|
||||
None
|
||||
else
|
||||
Some(value)
|
||||
}
|
||||
final def toList = Wrappers.toList(underlying)
|
||||
final def values = toList.map(_._2)
|
||||
}
|
||||
private[sbt] sealed class MutableMapWrapper[K,V](wrapped: JMap[K,V]) extends MapWrapper[K,V](wrapped) with Removable[K] with Addable[(K,V)]
|
||||
{
|
||||
final def getOrElseUpdate(key: K, default: => V): V =
|
||||
get(key) match
|
||||
{
|
||||
case Some(value) => value
|
||||
case None =>
|
||||
val newValue = default
|
||||
underlying.put(key, newValue)
|
||||
newValue
|
||||
}
|
||||
final def clear() = underlying.clear()
|
||||
final def update(key: K, value: V) { underlying.put(key, value) }
|
||||
final def +=(pair: (K, V) ) { update(pair._1, pair._2) }
|
||||
final def -=(key: K) { underlying.remove(key) }
|
||||
final def readOnly: Map[K,V] = this
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends DefaultProject(info) with Marker
|
||||
{
|
||||
lazy val interactiveTest = interactiveTask { mark() }
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends ParentProject(info) with Marker
|
||||
{
|
||||
val subA = project("a", "A")
|
||||
lazy val interactiveTest = interactiveTask { mark() }
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends ParentProject(info)
|
||||
{
|
||||
val subA = project("a", "A", new SubA(_))
|
||||
class SubA(info: ProjectInfo) extends DefaultProject(info) with Marker
|
||||
{
|
||||
lazy val interactiveTest = interactiveTask { mark() }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends ParentProject(info) with Marker
|
||||
{
|
||||
val subA = project("a", "A", new SubA(_))
|
||||
lazy val interactiveTest = interactiveTask { mark() }
|
||||
|
||||
class SubA(info: ProjectInfo) extends DefaultProject(info)
|
||||
{
|
||||
lazy val interactiveTest = interactiveTask { Some("Child interactive task should not be called.") }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends ParentProject(info)
|
||||
{
|
||||
val subA = project("a", "A", new SubA(_))
|
||||
lazy val interactiveTest = task { Some("Parent task should not be called") }
|
||||
|
||||
class SubA(info: ProjectInfo) extends DefaultProject(info)
|
||||
{
|
||||
lazy val interactiveTest = interactiveTask { Some("Child task should not be called.") }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends ParentProject(info) with Marker
|
||||
{
|
||||
val subA = project("a", "A", new SubA(_))
|
||||
lazy val interactiveTest = task { mark() }
|
||||
|
||||
class SubA(info: ProjectInfo) extends DefaultProject(info) with Marker
|
||||
{
|
||||
lazy val interactiveTest = task { mark() }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
#Project properties
|
||||
#Fri Jan 30 20:49:57 EST 2009
|
||||
project.name=Interactive Actions Test
|
||||
project.version=1.0
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
import sbt._
|
||||
|
||||
trait Marker extends NotNull
|
||||
{ self: Project =>
|
||||
def toMark: Path = "ran"
|
||||
def mark() =
|
||||
{
|
||||
if(toMark.exists)
|
||||
Some("Already ran")
|
||||
else
|
||||
FileUtilities.touch(toMark, log)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends DefaultProject(info) with Marker
|
||||
{
|
||||
lazy val interactiveTest = task { mark() }
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
# This test verifies the behavior of actions declared interactive
|
||||
|
||||
# Single project, non-interactive task
|
||||
> interactive-test [success]
|
||||
$ exists ran [success]
|
||||
$ delete ran [success]
|
||||
|
||||
# Single project, interactive task
|
||||
$ copy-file changes/TestProject2.scala project/build/src/TestProject.scala [success]
|
||||
$ reload [success]
|
||||
> interactive-test [success]
|
||||
$ exists ran [success]
|
||||
$ delete ran [success]
|
||||
|
||||
# Multi-project, single interactive task on parent project
|
||||
$ copy-file changes/TestProject3.scala project/build/src/TestProject.scala [success]
|
||||
$ reload [success]
|
||||
> interactive-test [success]
|
||||
$ exists ran [success]
|
||||
$ delete ran [success]
|
||||
|
||||
# Multi-project, single interactive task on child project
|
||||
$ copy-file changes/TestProject4.scala project/build/src/TestProject.scala [success]
|
||||
$ reload [success]
|
||||
> interactive-test [failure]
|
||||
|
||||
# Multi-project, two interactive tasks with same name, which is allowed because it is defined on parent
|
||||
$ copy-file changes/TestProject5.scala project/build/src/TestProject.scala [success]
|
||||
$ reload [success]
|
||||
> interactive-test [success]
|
||||
$ exists "ran" [success]
|
||||
$ delete "ran" [success]
|
||||
|
||||
# Multi-project, interactive on subproject + non-interactive on parent, which cannot be run from parent
|
||||
$ copy-file changes/TestProject6.scala project/build/src/TestProject.scala [success]
|
||||
$ reload [success]
|
||||
> interactive-test [failure]
|
||||
|
||||
# Multi-project, two non-interactive tasks with same name, which is allowed
|
||||
$ copy-file changes/TestProject7.scala project/build/src/TestProject.scala [success]
|
||||
$ reload [success]
|
||||
> interactive-test [success]
|
||||
$ exists "ran" [success]
|
||||
$ exists "a/ran" [success]
|
||||
$ delete "ran" [success]
|
||||
$ delete "a/ran" [success]
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
project.organization=test
|
||||
project.name=Interpreter Project Test
|
||||
project.version=1.0
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
import sbt._
|
||||
|
||||
class TestProject(info: ProjectInfo) extends DefaultProject(info)
|
||||
{
|
||||
override def useMavenConfigurations = true
|
||||
val sc = "org.scala-tools.testing" % "scalacheck" % "1.5" % "test->default"
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue