diff --git a/0.6.2.tar.gz b/0.6.2.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b43d32f9b578f915da33f7067839591b3bea77e6 Binary files /dev/null and b/0.6.2.tar.gz differ diff --git a/1.11.0.tar.gz b/1.11.0.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..abfc8d92663f603116ae24a6ed626a8f8dce81fc Binary files /dev/null and b/1.11.0.tar.gz differ diff --git a/SPECS2-1.12.3.tar.gz b/SPECS2-1.12.3.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1758fdb4318dc9cd9376bdfe4392497df77c6203 Binary files /dev/null and b/SPECS2-1.12.3.tar.gz differ diff --git a/climbing-nemesis.py b/climbing-nemesis.py new file mode 100644 index 0000000000000000000000000000000000000000..a5c85fed035950b62825100121b7ed7dcb08131e --- /dev/null +++ b/climbing-nemesis.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 + +# Copyright 2013, 2014 Red Hat, Inc., and William C. Benton +# +# 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. + +import xml.etree.ElementTree as ET +import argparse +import re +import logging + +from io import StringIO +from os.path import exists as pathexists +from os.path import realpath +from os.path import join as pathjoin +from os import makedirs +from os import symlink +from os import remove as rmfile +from shutil import copyfile +from javapackages.xmvn.xmvn_resolve import (XMvnResolve, ResolutionRequest) + +class Artifact(object): + def __init__(self, a, g, v): + self.artifact = a + self.group = g + self.version = v + + @classmethod + def fromCoords(k, coords): + g,a,v = coords.split(":") + return k(a, g, v) + + @classmethod + def fromSubtree(k, t, ns): + a = t.find("./%sartifactId" % ns).text + g = t.find("./%sgroupId" % ns).text + v = t.find("./%sversion" % ns).text + return k(a, g, v) + + def contains(self, substrings): + for s in substrings: + if s in self.artifact or s in self.group: + cn_debug("ignoring %r because it contains %s" % (self, s)) + return True + if len(substrings) > 0: + cn_debug("not ignoring %r; looked for %r" % (self, substrings)) + return False + + def __repr__(self): + return "%s:%s:%s" % (self.group, self.artifact, self.version) + +class DummyPOM(object): + def __init__(self, groupID=None, artifactID=None, version=None): + self.groupID = groupID + self.artifactID = artifactID + self.version = version + self.deps = [] + +def interestingDep(dt, namespace): + if len(dt.findall("./%soptional" % namespace)) != 0: + cn_debug("ignoring optional dep %r" % Artifact.fromSubtree(dt, namespace)) + return False + if [e for e in dt.findall("./%sscope" % namespace) if e.text == "test"] != []: + cn_debug("ignoring test dep %r" % Artifact.fromSubtree(dt, namespace)) + return False + return True + +class POM(object): + def __init__(self, filename, suppliedGroupID=None, suppliedArtifactID=None, ignored_deps=[], override=None, extra_deps=[]): + self.filename = filename + self.sGroupID = suppliedGroupID + self.sArtifactID = suppliedArtifactID + self.logger = logging.getLogger("com.freevariable.climbing-nemesis") + self.deps = [] + self.ignored_deps = ignored_deps + self.extra_deps = extra_deps + cn_debug("POM: extra_deps is %r" % extra_deps) + self._parsePom() + self.claimedGroup, self.claimedArtifact = override is not None and override or (self.groupID, self.artifactID) + + def _parsePom(self): + tree = ET.parse(self.filename) + project = tree.getroot() + self.logger.info("parsing POM %s", self.filename) + self.logger.debug("project tag is '%s'", project.tag) + tagmatch = re.match("[{](.*)[}].*", project.tag) + namespace = tagmatch and "{%s}" % tagmatch.groups()[0] or "" + self.logger.debug("looking for '%s'", ("./%sgroupId" % namespace)) + groupIDtag = project.find("./%sgroupId" % namespace) + if groupIDtag is None: + groupIDtag = project.find("./%sparent/%sgroupId" % (namespace,namespace)) + + versiontag = project.find("./%sversion" % namespace) + if versiontag is None: + versiontag = project.find("./%sparent/%sversion" % (namespace,namespace)) + self.logger.debug("group ID tag is '%s'", groupIDtag) + self.groupID = groupIDtag.text + self.artifactID = project.find("./%sartifactId" % namespace).text + self.version = versiontag.text + depTrees = project.findall(".//%sdependencies/%sdependency" % (namespace, namespace)) + alldeps = [Artifact.fromSubtree(depTree, namespace) for depTree in depTrees if interestingDep(depTree, namespace)] + alldeps = [dep for dep in alldeps if not (dep.group == self.groupID and dep.artifact == self.artifactID)] + self.deps = [dep for dep in alldeps if not dep.contains(self.ignored_deps)] + [Artifact.fromCoords(xtra) for xtra in self.extra_deps] + jarmatch = re.match(".*JPP-(.*).pom", self.filename) + self.jarname = (jarmatch and jarmatch.groups()[0] or None) + +def cn_debug(*args): + logging.getLogger("com.freevariable.climbing-nemesis").debug(*args) + +def cn_info(*args): + logging.getLogger("com.freevariable.climbing-nemesis").info(*args) + +def resolveArtifact(group, artifact, pomfile=None, ignored_deps=[], override=None, extra_deps=[]): + # XXX: some error checking would be the responsible thing to do here + cn_debug("rA: extra_deps is %r" % extra_deps) + if pomfile is None: + result = XMvnResolve.process_raw_request([ResolutionRequest(group, artifact, extension="pom")])[0] + if result: + return POM(result.artifactPath, ignored_deps=ignored_deps, override=override, extra_deps=extra_deps) + else: + return DummyPOM(group, artifact) + else: + return POM(pomfile, ignored_deps=ignored_deps, override=override, extra_deps=extra_deps) + +def resolveJar(group, artifact): + result = XMvnResolve.process_raw_request([ResolutionRequest(group, artifact)])[0] + return result.artifactPath if result else None + +def makeIvyXmlTree(org, module, revision, status="release", meta={}, deps=[]): + ivy_module = ET.Element("ivy-module", {"version":"1.0", "xmlns:e":"http://ant.apache.org/ivy/extra"}) + info = ET.SubElement(ivy_module, "info", dict({"organisation":org, "module":module, "revision":revision, "status":status}.items() | meta.items())) + info.text = " " # ensure a close tag + confs = ET.SubElement(ivy_module, "configurations") + for conf in ["default", "provided", "test"]: + ET.SubElement(confs, "conf", {"name":conf}) + pubs = ET.SubElement(ivy_module, "publications") + ET.SubElement(pubs, "artifact", {"name":module, "type":"jar"}) + if len(deps) > 0: + deptree = ET.SubElement(ivy_module, "dependencies") + for dep in deps: + ET.SubElement(deptree, "dependency", {"org":dep.group, "name":dep.artifact, "rev":dep.version}) + return ET.ElementTree(ivy_module) + +def writeIvyXml(org, module, revision, status="release", fileobj=None, meta={}, deps=[]): + # XXX: handle deps! + if fileobj is None: + fileobj = StringIO() + tree = makeIvyXmlTree(org, module, revision, status, meta=meta, deps=deps) + tree.write(fileobj, xml_declaration=True) + return fileobj + +def ivyXmlAsString(org, module, revision, status, meta={}, deps=[]): + return writeIvyXml(org, module, revision, status, meta=meta, deps=deps).getvalue() + +def placeArtifact(artifact_file, repo_dirname, org, module, revision, status="release", meta={}, deps=[], supplied_ivy_file=None, scala=None, override=None, override_dir_only=False): + if scala is not None: + module = module + "_%s" % scala + jarmodule = module + if override is not None: + org, module = override + if not override_dir_only: + jarmodule = module + repo_dir = realpath(repo_dirname) + artifact_dir = pathjoin(*[repo_dir] + [org] + [module, revision]) + ivyxml_path = pathjoin(artifact_dir, "ivy.xml") + artifact_repo_path = pathjoin(artifact_dir, "%s-%s.jar" % (jarmodule, revision)) + + if not pathexists(artifact_dir): + makedirs(artifact_dir) + + ivyxml_file = open(ivyxml_path, "wb") + if supplied_ivy_file is None: + writeIvyXml(org, module, revision, status, ivyxml_file, meta=meta, deps=deps) + else: + copyfile(supplied_ivy_file, ivyxml_path) + + if pathexists(artifact_repo_path): + rmfile(artifact_repo_path) + + symlink(artifact_file, artifact_repo_path) + +def main(): + parser = argparse.ArgumentParser(description="Place a locally-installed artifact in a custom local Ivy repository; get metadata from Maven") + parser.add_argument("group", metavar="GROUP", type=str, help="name of group") + parser.add_argument("artifact", metavar="ARTIFACT", type=str, help="name of artifact") + parser.add_argument("repodir", metavar="REPO", type=str, help="location for local repo") + parser.add_argument("--version", metavar="VERSION", type=str, help="version to advertise this artifact as, overriding Maven metadata") + parser.add_argument("--meta", metavar="K=V", type=str, help="extra metadata to store in ivy.xml", action='append') + parser.add_argument("--jarfile", metavar="JAR", type=str, help="local jar file (use instead of POM metadata") + parser.add_argument("--pomfile", metavar="POM", type=str, help="local pom file (use instead of xmvn-resolved one") + parser.add_argument("--log", metavar="LEVEL", type=str, help="logging level") + parser.add_argument("--ivyfile", metavar="IVY", type=str, help="supplied Ivy file (use instead of POM metadata)") + parser.add_argument("--scala", metavar="VERSION", type=str, help="encode given scala version in artifact name") + parser.add_argument("--ignore", metavar="STR", type=str, help="ignore dependencies whose artifact or group contains str", action='append') + parser.add_argument("--override", metavar="ORG:NAME", type=str, help="override organization and/or artifact name") + parser.add_argument("--override-dir-only", action='store_true', help="override organization and/or artifact name") + parser.add_argument("--extra-dep", metavar="ORG:NAME:VERSION", action='append', help="add the given dependencya") + args = parser.parse_args() + + if args.log is not None: + logging.basicConfig(level=getattr(logging, args.log.upper())) + + override = args.override and args.override.split(":") or None + cn_debug("cl: args.extra_dep is %r" % args.extra_dep) + extra_deps = args.extra_dep is not None and args.extra_dep or [] + + pom = resolveArtifact(args.group, args.artifact, args.pomfile, ignored_deps=(args.ignore or []), override=((not args.override_dir_only) and override or None), extra_deps=extra_deps) + + if args.jarfile is None: + jarfile = resolveJar(pom.groupID or args.group, pom.artifactID or args.artifact) + else: + jarfile = args.jarfile + + version = (args.version or pom.version) + + meta = dict([kv.split("=") for kv in (args.meta or [])]) + cn_debug("meta is %r" % meta) + + placeArtifact(jarfile, args.repodir, pom.groupID, pom.artifactID, version, meta=meta, deps=pom.deps, supplied_ivy_file=args.ivyfile, scala=args.scala, override=override, override_dir_only=args.override_dir_only) + +if __name__ == "__main__": + main() diff --git a/ivy-2.3.0-rc1.jar b/ivy-2.3.0-rc1.jar new file mode 100644 index 0000000000000000000000000000000000000000..6882e9009fb9f6d1c939b1287eded5e7d4daff18 Binary files /dev/null and b/ivy-2.3.0-rc1.jar differ diff --git a/ivy-2.3.0-rc1.pom b/ivy-2.3.0-rc1.pom new file mode 100644 index 0000000000000000000000000000000000000000..e540e4ffcbbdffc79a638ef44032b2680176c2c9 --- /dev/null +++ b/ivy-2.3.0-rc1.pom @@ -0,0 +1,157 @@ + + + + + 4.0.0 + + org.apache + apache + 7 + + org.apache.ivy + ivy + 2.3.0-rc1 + Apache Ivy + http://ant.apache.org/ivy/ + + scm:svn:http://svn.apache.org/repos/asf/ant/ivy/core/trunk/ + scm:svn:https://svn.apache.org/repos/asf/ant/ivy/core/trunk + http://svn.apache.org/repos/asf/ant/ivy/core/trunk + + + + Ant/Ivy Developers List + dev-subscribe@ant.apache.org + dev-unsubscribe@ant.apache.org + dev@ant.apache.org + http://mail-archives.apache.org/mod_mbox/ant-dev + + + Ivy Users List + ivy-user-subscribe@ant.apache.org + ivy-user-unsubscribe@ant.apache.org + ivy-user@ant.apache.org + http://mail-archives.apache.org/mod_mbox/ant-ivy-user + + + + jira + http://issues.apache.org/jira/browse/IVY + + + + org.apache.ant + ant + 1.7.1 + true + + + org.apache.ant + ant-nodeps + 1.7.1 + true + + + org.apache.ant + ant-trax + 1.7.1 + true + + + commons-httpclient + commons-httpclient + 3.0 + true + + + oro + oro + 2.0.8 + true + + + commons-vfs + commons-vfs + 1.0 + true + + + com.jcraft + jsch + 0.1.31 + true + + + org.bouncycastle + bcpg-jdk14 + 1.45 + true + + + org.bouncycastle + bcprov-jdk14 + 1.45 + true + + + junit + junit + 3.8.2 + test + + + commons-lang + commons-lang + 2.6 + test + + + org.apache.ant + ant-testutil + 1.7.0 + test + + + ant + ant-launcher + 1.6.2 + test + + + ant-contrib + ant-contrib + 1.0b3 + test + + + xerces + xercesImpl + 2.6.2 + test + + + xerces + xmlParserAPIs + 2.6.2 + test + + + diff --git a/ivy-2.3.0.pom b/ivy-2.3.0.pom new file mode 100644 index 0000000000000000000000000000000000000000..1212775f882dd451ea12106ae6effcd529378bae --- /dev/null +++ b/ivy-2.3.0.pom @@ -0,0 +1,157 @@ + + + + + 4.0.0 + + org.apache + apache + 7 + + org.apache.ivy + ivy + 2.3.0 + Apache Ivy + http://ant.apache.org/ivy/ + + scm:svn:http://svn.apache.org/repos/asf/ant/ivy/core/trunk/ + scm:svn:https://svn.apache.org/repos/asf/ant/ivy/core/trunk + http://svn.apache.org/repos/asf/ant/ivy/core/trunk + + + + Ant/Ivy Developers List + dev-subscribe@ant.apache.org + dev-unsubscribe@ant.apache.org + dev@ant.apache.org + http://mail-archives.apache.org/mod_mbox/ant-dev + + + Ivy Users List + ivy-user-subscribe@ant.apache.org + ivy-user-unsubscribe@ant.apache.org + ivy-user@ant.apache.org + http://mail-archives.apache.org/mod_mbox/ant-ivy-user + + + + jira + http://issues.apache.org/jira/browse/IVY + + + + org.apache.ant + ant + 1.7.1 + true + + + org.apache.ant + ant-nodeps + 1.7.1 + true + + + org.apache.ant + ant-trax + 1.7.1 + true + + + commons-httpclient + commons-httpclient + 3.0 + true + + + oro + oro + 2.0.8 + true + + + commons-vfs + commons-vfs + 1.0 + true + + + com.jcraft + jsch + 0.1.31 + true + + + org.bouncycastle + bcpg-jdk14 + 1.45 + true + + + org.bouncycastle + bcprov-jdk14 + 1.45 + true + + + junit + junit + 3.8.2 + test + + + commons-lang + commons-lang + 2.6 + test + + + org.apache.ant + ant-testutil + 1.7.0 + test + + + ant + ant-launcher + 1.6.2 + test + + + ant-contrib + ant-contrib + 1.0b3 + test + + + xerces + xercesImpl + 2.6.2 + test + + + xerces + xmlParserAPIs + 2.6.2 + test + + + diff --git a/rpmbuild-sbt.boot.properties b/rpmbuild-sbt.boot.properties new file mode 100644 index 0000000000000000000000000000000000000000..67501fb52ba9ec54a2c0fcf6b2c047357c1f2228 --- /dev/null +++ b/rpmbuild-sbt.boot.properties @@ -0,0 +1,25 @@ +[scala] + version: FEDORA_SCALA_VERSION + +[app] + org: ${sbt.organization-org.scala-sbt} + name: sbt + version: ${sbt.version-read(sbt.version)[FEDORA_SBT_VERSION]} + class: ${sbt.main.class-sbt.xMain} + components: xsbti,extra + cross-versioned: ${sbt.cross.versioned-false} + +[repositories] + local: file:${fedora.sbt.ivy.dir-/usr/share/sbt/ivy-local}, [organization]/[module]/[revision]/ivy.xml, [organization]/[module]/[revision]/[artifact]-[revision].[ext] + +[boot] + directory: ${fedora.sbt.boot.dir-/usr/share/sbt/boot} + +[log] + level: debug + +[ivy] + ivy-home: ${fedora.sbt.ivy.dir-/usr/share/sbt/ivy-local} + checksums: ${sbt.checksums-sha1,md5} + override-build-repos: true + diff --git a/sbt b/sbt new file mode 100644 index 0000000000000000000000000000000000000000..c303f649e373f8afe741460ab6897a0bb074d1a4 --- /dev/null +++ b/sbt @@ -0,0 +1,17 @@ +#!/bin/sh + +export JLINE=jline + +export SBT_BOOT_DIR=${SBT_BOOT_DIR:-/usr/share/sbt/boot} +export SBT_IVY_DIR=${SBT_IVY_DIR:-/usr/share/sbt/ivy-local} + +if \[ "x$RPM_PACKAGE_NAME" != x \] && \[ -f /etc/sbt/rpmbuild-sbt.boot.properties \] ; then + export SBT_BOOT_PROPERTIES=${SBT_BOOT_PROPERTIES:-/etc/sbt/rpmbuild-sbt.boot.properties} +else + export SBT_BOOT_PROPERTIES=${SBT_BOOT_PROPERTIES:-/etc/sbt/sbt.boot.properties} +fi + +export BASE_CLASSPATH=$(build-classpath scala ivy sbt ${JLINE} jansi test-interface sbinary) +export JAVA_OPTS="-Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled" + +java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -Dfedora.sbt.boot.dir=${SBT_BOOT_DIR} -Dfedora.sbt.ivy.dir=${SBT_IVY_DIR} -Dsbt.boot.properties=${SBT_BOOT_PROPERTIES} -cp ${BASE_CLASSPATH} xsbt.boot.Boot "$@" diff --git a/sbt-0.13.1-9.fc28.1.noarch.rpm b/sbt-0.13.1-9.fc28.1.noarch.rpm new file mode 100644 index 0000000000000000000000000000000000000000..8bd7d7a88354af725a8f517093908424b080ea57 Binary files /dev/null and b/sbt-0.13.1-9.fc28.1.noarch.rpm differ diff --git a/sbt-0.13.1-RC3-release-scala.patch b/sbt-0.13.1-RC3-release-scala.patch new file mode 100644 index 0000000000000000000000000000000000000000..caa8175ac69a81a051c1cb67d4fa93fe1308cc7b --- /dev/null +++ b/sbt-0.13.1-RC3-release-scala.patch @@ -0,0 +1,12 @@ +--- old/project/Release.scala 2013-11-23 13:43:58.498256144 -0600 ++++ new/project/Release.scala 2013-11-25 21:08:00.113468064 -0600 +@@ -39,9 +39,6 @@ + def deployLauncher(launcher: TaskKey[File]) = + (launcher, launcherRemotePath, credentials, remoteBase, streams) map { (launchJar, remotePath, creds, base, s) => + val (uname, pwd) = getCredentials(creds, s.log) +- val request = dispatch.classic.url(base) / remotePath <<< (launchJar, "binary/octet-stream") as (uname, pwd) +- val http = new dispatch.classic.Http +- try { http(request.as_str) } finally { http.shutdown() } + () + } + def getCredentials(cs: Seq[Credentials], log: Logger): (String, String) = diff --git a/sbt-0.13.1-ivy-2.3.0.patch b/sbt-0.13.1-ivy-2.3.0.patch new file mode 100644 index 0000000000000000000000000000000000000000..40bd7cd8a94d7be66db4fa06006e0c4f0c43466f --- /dev/null +++ b/sbt-0.13.1-ivy-2.3.0.patch @@ -0,0 +1,150 @@ +From ea9a2931f69e87fdcf5a8bce02940a30ea4ab56c Mon Sep 17 00:00:00 2001 +From: William Benton +Date: Fri, 13 Dec 2013 11:39:09 -0600 +Subject: [PATCH 1/2] Support Ivy 2.3.0-final. + +This entailed modifying ResolutionCache and the CustomPomParser +to reflect changes to the ResolutionCacheManager interface and +DefaultExtendsDescriptor class between Ivy 2.3.0-rc1 and +2.3.0-rc2. Specifically, + +1. ResolutionCacheManager now includes two additional methods +that needed implementations in ResolutionCache: +getResolvedModuleDescriptor(mrid: ModuleRevisionId) and +saveResolvedModuleDescriptor(md: ModuleDescriptor). I adapted +the implementations for these (which are expressed primarily in +terms of other interface methods) from Ivy 2.3.0's +DefaultResolutionCacheManager. + +2. Instead of taking a ModuleRevisionIdentifier and a resolved +ModuleRevisionIdentifier as its first two arguments, the +DefaultExtendsDescriptor constructor now takes a +ModuleDescriptor. This was a trivial change. + +Note that ResolutionCache.getResolvedModuleDescriptor does not +appear to be used by Ivy as sbt uses Ivy and there is thus no +test coverage for its implementation. Also note that the +DefaultResolutionCacheManager object created in +Update.configureResolutionCache now requires a reference to an +IvySettings object; DRCM expects this to be non-null. +--- + ivy/src/main/scala/sbt/CustomPomParser.scala | 2 +- + ivy/src/main/scala/sbt/Ivy.scala | 2 +- + ivy/src/main/scala/sbt/ResolutionCache.scala | 27 ++++++++++++++++++++++++++- + launch/src/main/scala/xsbt/boot/Update.scala | 4 +++- + project/Util.scala | 2 +- + 5 files changed, 32 insertions(+), 5 deletions(-) + +diff --git a/ivy/src/main/scala/sbt/CustomPomParser.scala b/ivy/src/main/scala/sbt/CustomPomParser.scala +index 34147d9..7023ab8 100644 +--- a/ivy/src/main/scala/sbt/CustomPomParser.scala ++++ b/ivy/src/main/scala/sbt/CustomPomParser.scala +@@ -203,7 +203,7 @@ object CustomPomParser + val unique = IvySbt.mergeDuplicateDefinitions(withExtra) + unique foreach dmd.addDependency + +- for( ed <- md.getInheritedDescriptors) dmd.addInheritedDescriptor( new DefaultExtendsDescriptor( mrid, resolvedMrid, ed.getLocation, ed.getExtendsTypes) ) ++ for( ed <- md.getInheritedDescriptors) dmd.addInheritedDescriptor( new DefaultExtendsDescriptor( md, ed.getLocation, ed.getExtendsTypes) ) + for( conf <- md.getConfigurations) { + dmd.addConfiguration(conf) + for(art <- md.getArtifacts(conf.getName)) { +diff --git a/ivy/src/main/scala/sbt/Ivy.scala b/ivy/src/main/scala/sbt/Ivy.scala +index 6154bdb..e1dca53 100644 +--- a/ivy/src/main/scala/sbt/Ivy.scala ++++ b/ivy/src/main/scala/sbt/Ivy.scala +@@ -310,7 +310,7 @@ private object IvySbt + private[this] def configureResolutionCache(settings: IvySettings, localOnly: Boolean, resCacheDir: Option[File]) + { + val base = resCacheDir getOrElse settings.getDefaultResolutionCacheBasedir +- settings.setResolutionCacheManager(new ResolutionCache(base)) ++ settings.setResolutionCacheManager(new ResolutionCache(base, settings)) + } + // set the artifact resolver to be the main resolver. + // this is because sometimes the artifact resolver saved in the cache is not correct +diff --git a/ivy/src/main/scala/sbt/ResolutionCache.scala b/ivy/src/main/scala/sbt/ResolutionCache.scala +index ab69344..1243420 100644 +--- a/ivy/src/main/scala/sbt/ResolutionCache.scala ++++ b/ivy/src/main/scala/sbt/ResolutionCache.scala +@@ -1,18 +1,24 @@ + package sbt + + import java.io.File ++import java.io.FileInputStream ++import java.util.Properties + import org.apache.ivy.core ++import org.apache.ivy.plugins.parser + import core.IvyPatternHelper ++import core.settings.IvySettings + import core.cache.{CacheMetadataOptions, DefaultRepositoryCacheManager, DefaultResolutionCacheManager, ResolutionCacheManager} + import core.module.id.ModuleRevisionId ++import core.module.descriptor.ModuleDescriptor + import ResolutionCache.{Name, ReportDirectory, ResolvedName, ResolvedPattern} ++import parser.xml.XmlModuleDescriptorParser + + /** Replaces the standard Ivy resolution cache in order to: + * 1. Separate cached resolved Ivy files from resolution reports, making the resolution reports easier to find. + * 2. Have them per-project for easier cleaning (possible with standard cache, but central to this custom one). + * 3. Cache location includes extra attributes so that cross builds of a plugin do not overwrite each other. + */ +-private[sbt] final class ResolutionCache(base: File) extends ResolutionCacheManager ++private[sbt] final class ResolutionCache(base: File, settings: IvySettings) extends ResolutionCacheManager + { + private[this] def resolvedFileInCache(m: ModuleRevisionId, name: String, ext: String): File = { + val p = ResolvedPattern +@@ -35,6 +41,25 @@ private[sbt] final class ResolutionCache(base: File) extends ResolutionCacheMana + new File(reportBase, resolveId + "-" + conf + ".xml") + def getConfigurationResolveReportsInCache(resolveId: String): Array[File] = + IO.listFiles(reportBase).filter(_.getName.startsWith(resolveId + "-")) ++ ++ // XXX: this method is required by ResolutionCacheManager in Ivy 2.3.0 final, ++ // but it is apparently unused by Ivy as sbt uses Ivy. Therefore, it is ++ // unexercised in tests. Note that the implementation of this method in Ivy 2.3.0's ++ // DefaultResolutionCache also resolves parent properties for a given mrid ++ def getResolvedModuleDescriptor(mrid: ModuleRevisionId): ModuleDescriptor = { ++ val ivyFile = getResolvedIvyFileInCache(mrid) ++ if (!ivyFile.exists()) { ++ throw new IllegalStateException("Ivy file not found in cache for " + mrid + "!") ++ } ++ ++ return XmlModuleDescriptorParser.getInstance().parseDescriptor(settings, ivyFile.toURI().toURL(), false) ++ } ++ ++ def saveResolvedModuleDescriptor(md: ModuleDescriptor): Unit = { ++ val mrid = md.getResolvedModuleRevisionId ++ val cachedIvyFile = getResolvedIvyFileInCache(mrid) ++ md.toIvyFile(cachedIvyFile) ++ } + } + private[sbt] object ResolutionCache + { +diff --git a/launch/src/main/scala/xsbt/boot/Update.scala b/launch/src/main/scala/xsbt/boot/Update.scala +index a39a70f..6c8c9f3 100644 +--- a/launch/src/main/scala/xsbt/boot/Update.scala ++++ b/launch/src/main/scala/xsbt/boot/Update.scala +@@ -286,7 +286,9 @@ final class Update(config: UpdateConfiguration) + private[this] def configureResolutionCache(settings: IvySettings) + { + resolutionCacheBase.mkdirs() +- settings.setResolutionCacheManager(new DefaultResolutionCacheManager(resolutionCacheBase)) ++ val drcm = new DefaultResolutionCacheManager(resolutionCacheBase) ++ drcm.setSettings(settings) ++ settings.setResolutionCacheManager(drcm) + } + private[this] def configureRepositoryCache(settings: IvySettings) + { +diff --git a/project/Util.scala b/project/Util.scala +index afddf87..13f99a0 100644 +--- a/project/Util.scala ++++ b/project/Util.scala +@@ -167,7 +167,7 @@ object Common + def lib(m: ModuleID) = libraryDependencies += m + lazy val jlineDep = "jline" % "jline" % "2.11" + lazy val jline = lib(jlineDep) +- lazy val ivy = lib("org.apache.ivy" % "ivy" % "2.3.0-rc1") ++ lazy val ivy = lib("org.apache.ivy" % "ivy" % "2.3.0") + lazy val httpclient = lib("commons-httpclient" % "commons-httpclient" % "3.1") + lazy val jsch = lib("com.jcraft" % "jsch" % "0.1.46" intransitive() ) + lazy val sbinary = libraryDependencies <+= Util.nightly211(n => "org.scala-tools.sbinary" % "sbinary" % "0.4.2" cross(if(n) CrossVersion.full else CrossVersion.binary)) +-- +1.8.3.4 (Apple Git-47) + diff --git a/sbt-0.13.1-ivy-2.4.0.patch b/sbt-0.13.1-ivy-2.4.0.patch new file mode 100644 index 0000000000000000000000000000000000000000..98d5c80a28c53f63b4e198a089ec7925dbb7d01c --- /dev/null +++ b/sbt-0.13.1-ivy-2.4.0.patch @@ -0,0 +1,11 @@ +--- ivy/src/main/scala/sbt/IvyLogger.scala~ 2015-07-21 12:06:06.883992874 +0200 ++++ ivy/src/main/scala/sbt/IvyLogger.scala 2015-07-21 12:06:20.516805104 +0200 +@@ -31,7 +31,7 @@ + def warn(msg: String) = logger.warn(msg) + def error(msg: String) = if(SbtIvyLogger.acceptError(msg)) logger.error(msg) + +- private def emptyList = java.util.Collections.emptyList[T forSome { type T}] ++ private def emptyList = java.util.Collections.emptyList[String] + def getProblems = emptyList + def getWarns = emptyList + def getErrors = emptyList diff --git a/sbt-0.13.1-ivy-docs.patch b/sbt-0.13.1-ivy-docs.patch new file mode 100644 index 0000000000000000000000000000000000000000..133cc9e16cb57b756e27d1bd6e9e257cb8043063 --- /dev/null +++ b/sbt-0.13.1-ivy-docs.patch @@ -0,0 +1,92 @@ +From 8c6bddc7296652f0734c70a5f237c488fb5d8798 Mon Sep 17 00:00:00 2001 +From: William Benton +Date: Fri, 13 Dec 2013 12:51:59 -0600 +Subject: [PATCH 2/2] Update documentation references to Ivy 2.3.0 + +--- + src/sphinx/Detailed-Topics/Artifacts.rst | 2 +- + src/sphinx/Detailed-Topics/Library-Management.rst | 8 ++++---- + src/sphinx/Detailed-Topics/Publishing.rst | 2 +- + src/sphinx/Getting-Started/Library-Dependencies.rst | 2 +- + 4 files changed, 7 insertions(+), 7 deletions(-) + +diff --git a/src/sphinx/Detailed-Topics/Artifacts.rst b/src/sphinx/Detailed-Topics/Artifacts.rst +index 845c7e1..b6d9e45 100644 +--- a/src/sphinx/Detailed-Topics/Artifacts.rst ++++ b/src/sphinx/Detailed-Topics/Artifacts.rst +@@ -128,7 +128,7 @@ For example: + Artifact("myproject", "jdk15") + + See the `Ivy +-documentation `_ ++documentation `_ + for more details on artifacts. See the `Artifact + API <../../api/sbt/Artifact$.html>`_ for + combining the parameters above and specifying [Configurations] and extra +diff --git a/src/sphinx/Detailed-Topics/Library-Management.rst b/src/sphinx/Detailed-Topics/Library-Management.rst +index 8dc2e9c..a01a514 100644 +--- a/src/sphinx/Detailed-Topics/Library-Management.rst ++++ b/src/sphinx/Detailed-Topics/Library-Management.rst +@@ -124,7 +124,7 @@ the version of Scala you are using. See :doc:`Cross-Build` for details. + Ivy can select the latest revision of a module according to constraints + you specify. Instead of a fixed revision like `"1.6.1"`, you specify + `"latest.integration"`, `"2.9.+"`, or `"[1.0,)"`. See the `Ivy +-revisions `_ ++revisions `_ + documentation for details. + + Resolvers +@@ -320,7 +320,7 @@ Extra Attributes + ~~~~~~~~~~~~~~~~ + + `Extra +-attributes `_ ++attributes `_ + can be specified by passing key/value pairs to the `extra` method. + + To select dependencies by extra attributes: +@@ -527,7 +527,7 @@ Configurations + Ivy configurations are a useful feature for your build when you need + custom groups of dependencies, such as for a plugin. Ivy configurations + are essentially named sets of dependencies. You can read the +-`Ivy documentation `_ ++`Ivy documentation `_ + for details. + + The built-in use of configurations in sbt is similar to scopes in Maven. +@@ -549,7 +549,7 @@ your dependency definition: + + This says that your project's `"test"` configuration uses + `ScalaTest`'s `"compile"` configuration. See the `Ivy +-documentation `_ ++documentation `_ + for more advanced mappings. Most projects published to Maven + repositories will use the `"compile"` configuration. + +diff --git a/src/sphinx/Detailed-Topics/Publishing.rst b/src/sphinx/Detailed-Topics/Publishing.rst +index 67dc2bb..ea5d7a2 100644 +--- a/src/sphinx/Detailed-Topics/Publishing.rst ++++ b/src/sphinx/Detailed-Topics/Publishing.rst +@@ -163,5 +163,5 @@ change the version number each time you publish. Ivy maintains a cache, + and it stores even local projects in that cache. If Ivy already has a + version cached, it will not check the local repository for updates, + unless the version number matches a `changing +-pattern `_, ++pattern `_, + and `SNAPSHOT` is one such pattern. +diff --git a/src/sphinx/Getting-Started/Library-Dependencies.rst b/src/sphinx/Getting-Started/Library-Dependencies.rst +index 536fe8a..08f84ab 100644 +--- a/src/sphinx/Getting-Started/Library-Dependencies.rst ++++ b/src/sphinx/Getting-Started/Library-Dependencies.rst +@@ -155,7 +155,7 @@ be a single fixed version. Ivy can select the latest revision of a + module according to constraints you specify. Instead of a fixed revision + like `"1.6.1"`, you specify `"latest.integration"`, `"2.9.+"`, or + `"[1.0,)"`. See the `Ivy +-revisions `_ ++revisions `_ + documentation for details. + + Resolvers +-- +1.8.3.4 (Apple Git-47) + diff --git a/sbt-0.13.1-sbt-scala.patch b/sbt-0.13.1-sbt-scala.patch new file mode 100644 index 0000000000000000000000000000000000000000..7fb5f122d632c0ff58aabe0aed07c51588641c69 --- /dev/null +++ b/sbt-0.13.1-sbt-scala.patch @@ -0,0 +1,42 @@ +--- old/project/Sbt.scala 2013-11-23 13:43:58.498256144 -0600 ++++ new/project/Sbt.scala 2013-11-26 09:59:50.591828593 -0600 +@@ -15,6 +15,7 @@ + def buildSettings = Seq( + organization := "org.scala-sbt", + version := "0.13.1", ++ scalaHome := Some(file("scala")), + publishArtifact in packageDoc := false, + scalaVersion := "2.10.3", + publishMavenStyle := false, +@@ -97,9 +98,6 @@ + // Compiler-side interface to compiler that is compiled against the compiler being used either in advance or on the fly. + // Includes API and Analyzer phases that extract source API and relationships. + lazy val compileInterfaceSub = baseProject(compilePath / "interface", "Compiler Interface") dependsOn(interfaceSub, ioSub % "test->test", logSub % "test->test", launchSub % "test->test") settings( compileInterfaceSettings : _*) +- lazy val precompiled282 = precompiled("2.8.2") +- lazy val precompiled292 = precompiled("2.9.2") +- lazy val precompiled293 = precompiled("2.9.3") + + // Implements the core functionality of detecting and propagating changes incrementally. + // Defines the data structures for representing file fingerprints and relationships and the overall source analysis +@@ -135,7 +133,7 @@ + // Strictly for bringing implicits and aliases from subsystems into the top-level sbt namespace through a single package object + // technically, we need a dependency on all of mainSub's dependencies, but we don't do that since this is strictly an integration project + // with the sole purpose of providing certain identifiers without qualification (with a package object) +- lazy val sbtSub = baseProject(sbtPath, "sbt") dependsOn(mainSub, compileInterfaceSub, precompiled282, precompiled292, precompiled293, scriptedSbtSub % "test->test") settings(sbtSettings : _*) ++ lazy val sbtSub = baseProject(sbtPath, "sbt") dependsOn(mainSub, compileInterfaceSub, scriptedSbtSub % "test->test") settings(sbtSettings : _*) + + /* Nested subproject paths */ + def sbtPath = file("sbt") +@@ -211,10 +209,10 @@ + publishAll <<= inAll(nonRoots, publishLocal.task), + publishAll <<= (publishAll, publishLocal).map((x,y)=> ()) // publish all normal deps as well as the sbt-launch jar + ) +- def fullDocSettings = Util.baseScalacOptions ++ Docs.settings ++ Sxr.settings ++ Seq( ++ def fullDocSettings = Util.baseScalacOptions ++ Sxr.settings ++ Seq( + scalacOptions += "-Ymacro-no-expand", // for both sxr and doc + sources in sxr <<= deepTasks(sources in Compile), //sxr +- sources in (Compile,doc) <<= sources in sxr, // doc ++ sources in (Compile) <<= sources in sxr, // doc + Sxr.sourceDirectories <<= deep(sourceDirectories in Compile).map(_.flatten), // to properly relativize the source paths + fullClasspath in sxr <<= (externalDependencyClasspath in Compile in sbtSub), + dependencyClasspath in (Compile,doc) <<= fullClasspath in sxr diff --git a/sbt-0.13.1-sxr.patch b/sbt-0.13.1-sxr.patch new file mode 100644 index 0000000000000000000000000000000000000000..efb402615574b115749caa3005d6255e0f013733 --- /dev/null +++ b/sbt-0.13.1-sxr.patch @@ -0,0 +1,19 @@ +--- a/project/Sxr.scala 2014-01-20 15:50:18.561978172 -0600 ++++ b/project/Sxr.scala 2014-01-20 15:35:04.949702779 -0600 +@@ -11,15 +11,10 @@ + lazy val settings: Seq[Setting[_]] = inTask(sxr)(inSxrSettings) ++ baseSettings + + def baseSettings = Seq( +- libraryDependencies += "org.scala-sbt.sxr" % "sxr_2.10" % "0.3.0" % sxrConf.name + ) + def inSxrSettings = Seq( + managedClasspath := update.value.matching( configurationFilter(sxrConf.name) ).classpath, +- scalacOptions += "-P:sxr:base-directory:" + sourceDirectories.value.absString, +- scalacOptions += "-Xplugin:" + managedClasspath.value.files.filter(_.getName.contains("sxr")).absString, +- scalacOptions += "-Ystop-after:sxr", +- target := target.in(taskGlobal).value / "browse", +- sxr in taskGlobal <<= sxrTask ++ scalacOptions += "-P:sxr:base-directory:" + sourceDirectories.value.absString + ) + def taskGlobal = ThisScope.copy(task = Global) + def sxrTask = (sources, target, scalacOptions, classpathOptions, scalaInstance, fullClasspath, streams) map { (srcs, out, opts, cpOpts, si, cp, s) => diff --git a/sbt.boot.properties b/sbt.boot.properties new file mode 100644 index 0000000000000000000000000000000000000000..8a8d83dab48ceb38a807bd41a9d23893cab743a4 --- /dev/null +++ b/sbt.boot.properties @@ -0,0 +1,26 @@ +[scala] + version: FEDORA_SCALA_VERSION + +[app] + org: ${sbt.organization-org.scala-sbt} + name: sbt + version: ${sbt.version-read(sbt.version)[FEDORA_SBT_VERSION]} + class: ${sbt.main.class-sbt.xMain} + components: xsbti,extra + cross-versioned: ${sbt.cross.versioned-false} + +[repositories] + local + fedora: file:${fedora.sbt.ivy.dir-ivy-local}, [organization]/[module]/[revision]/ivy.xml, [organization]/[module]/[revision]/[artifact]-[revision].[ext] + typesafe-ivy-releases: http://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly + maven-central + sonatype-snapshots: https://oss.sonatype.org/content/repositories/snapshots + +[boot] + directory: ${sbt.boot.directory-${sbt.global.base-${user.home}/.sbt}/boot/} + +[ivy] + ivy-home: ${sbt.ivy.home-${user.home}/.ivy2/} + checksums: ${sbt.checksums-sha1,md5} + override-build-repos: ${sbt.override.build.repos-false} + repository-config: ${sbt.repository.config-${sbt.global.base-${user.home}/.sbt}/repositories} \ No newline at end of file diff --git a/sbt.spec b/sbt.spec new file mode 100644 index 0000000000000000000000000000000000000000..632d3efb007ed956719dbbfea043d28d60ea3ffd --- /dev/null +++ b/sbt.spec @@ -0,0 +1,481 @@ +# doing a bootstrap build from public sbt binaries +%global do_bootstrap 0 + +# build non-bootstrap packages with tests, cross-referenced sources, etc +%global do_proper 0 +%global scala_version 2.10.6 +%global scala_short_version 2.10 +%global sbt_bootstrap_version 0.13.1 +%global sbt_major 0 +%global sbt_minor 13 +%global sbt_patch 1 +%global sbt_build %{nil} +%global sbt_short_version %{sbt_major}.%{sbt_minor} +%global sbt_version %{sbt_major}.%{sbt_minor}.%{sbt_patch} +%global sbt_full_version %{sbt_version}%{sbt_build} +%global typesafe_repo http://repo.typesafe.com/typesafe/ivy-releases + +%global ivy_local_dir ivy-local + +%global installed_ivy_local %{_datadir}/%{name}/%{ivy_local_dir} + +%global generic_ivy_artifact() %{1}/%{2}/%{3}/%{4}/jars/%{5}.jar +%global generic_ivy_descriptor() %{1}/%{2}/%{3}/%{4}/ivys/ivy.xml#/%{5}-%{4}-ivy.xml + +%global sbt_ivy_artifact() %{typesafe_repo}/org.scala-sbt/%{1}/%{sbt_bootstrap_version}/jars/%{1}.jar +%global sbt_ivy_descriptor() %{typesafe_repo}/org.scala-sbt/%{1}/%{sbt_bootstrap_version}/ivys/ivy.xml#/%{1}-%{sbt_bootstrap_version}-ivy.xml + +%global sbt_ghpages_version 0.5.1 +%global sbt_git_version 0.6.3 +%global sbt_site_version 0.6.2 +%global sbt_site_jar_version 0.6.2 + +%global want_sxr 1 +%global want_specs2 0 +%global want_scalacheck 1 +%global want_dispatch_http 1 + + +%global sxr_version 0.3.0 +%global sbinary_version 0.4.2 +%global scalacheck_version 1.11.0 +%global specs2_version 1.12.3 +%global testinterface_version 1.0 +%global dispatch_http_version 0.8.9 + +Name: sbt +Version: %{sbt_version} +Release: 1 +Summary: The simple build tool for Scala and Java projects + +BuildArch: noarch + +License: BSD +URL: http://www.scala-sbt.org +Source0: https://github.com/sbt/sbt/archive/v%{version}%{sbt_build}.tar.gz +Patch0: sbt-0.13.1-sbt-scala.patch +Patch1: sbt-0.13.1-RC3-release-scala.patch +Patch2: sbt-0.13.1-ivy-2.3.0.patch +Patch3: sbt-0.13.1-ivy-docs.patch +Patch4: sbt-0.13.1-sxr.patch +Patch5: sbt-0.13.1-ivy-2.4.0.patch + +# sbt-ghpages plugin +Source1: https://github.com/sbt/sbt-ghpages/archive/v%{sbt_ghpages_version}.tar.gz + +# sbt-git plugin +Source2: https://github.com/sbt/sbt-git/archive/v%{sbt_git_version}.tar.gz + +# sbt-site plugin +Source3: https://github.com/sbt/sbt-site/archive/%{sbt_site_version}.tar.gz + +# sxr +Source4: https://github.com/harrah/browse/archive/v%{sxr_version}.tar.gz + +# scalacheck +# nb: no "v" in this tarball URL +%if %{?want_scalacheck} +Source6: https://github.com/rickynils/scalacheck/archive/%{scalacheck_version}.tar.gz +%endif + +# specs +# nb: no "v" in this tarball url +# nb: this depends on scalaz; might need to excise +Source7: https://github.com/etorreborre/specs2/archive/SPECS2-%{specs2_version}.tar.gz + +Source16: https://raw.github.com/willb/climbing-nemesis/master/climbing-nemesis.py +Source17: https://raw.github.com/willb/rpm-packaging/master/sbt-packaging/sbt.boot.properties +Source15: https://raw.github.com/willb/rpm-packaging/master/sbt-packaging/rpmbuild-sbt.boot.properties + +# Ivy POM +# necessary for bootstrapping with sbt 0.13.1 +Source18: http://repo1.maven.org/maven2/org/apache/ivy/ivy/2.3.0-rc1/ivy-2.3.0-rc1.pom +# necessary for F19 (which doesn't ship with an Ivy pom) +Source20: http://repo1.maven.org/maven2/org/apache/ivy/ivy/2.3.0/ivy-2.3.0.pom + +# Ivy 2.3.0-rc1 jar (necessary for bootstrapping with sbt 0.13.1) +Source19: http://repo1.maven.org/maven2/org/apache/ivy/ivy/2.3.0-rc1/ivy-2.3.0-rc1.jar + + +# sbt script (to be obsoleted in future releases) +Source21: https://raw.github.com/willb/rpm-packaging/master/sbt-packaging/sbt + +BuildRequires: mvn(org.scala-lang:scala-compiler) java-devel python3 +# maven is required because climbing-nemesis.py uses xmvn-resolve +BuildRequires: maven-local + +BuildRequires: mvn(org.bouncycastle:bcprov-jdk16) mvn(org.bouncycastle:bcpg-jdk16) hawtjni +BuildRequires: mvn(org.fusesource.jansi:jansi) jline2 proguard + +BuildRequires: javapackages-tools +Requires: javapackages-tools + +BuildRequires: mvn(oro:oro) mvn(com.jcraft:jsch) mvn(commons-httpclient:commons-httpclient) +BuildRequires: apache-ivy mvn(org.scala-lang:scala-compiler) mvn(org.scala-lang:scala-library) +BuildRequires: mvn(org.scala-lang:scala-reflect) mvn(org.jsoup:jsoup) + +Requires: mvn(oro:oro) mvn(com.jcraft:jsch) mvn(commons-httpclient:commons-httpclient) +Requires: apache-ivy mvn(org.scala-lang:scala-compiler) mvn(org.scala-lang:scala-library) +Requires: mvn(org.scala-lang:scala-reflect) mvn(org.jsoup:jsoup) proguard + +Requires: mvn(org.bouncycastle:bcprov-jdk16) mvn(org.bouncycastle:bcpg-jdk16) +Requires: mvn(org.fusesource.jansi:jansi) jline2 + +BuildRequires: sbinary = %{sbinary_version} test-interface = %{testinterface_version} + +Requires: sbinary = %{sbinary_version} test-interface = %{testinterface_version} + +%if !%{do_bootstrap} +BuildRequires: sbt = %{sbt_bootstrap_version} + +%if %{do_proper} +BuildRequires: sbt-ghpages = %{sbt_ghpages_version} sbt-site = %{sbt_site_version} +BuildRequires: sbt-git = %{sbt_git_version} + +BuildRequires: sxr = %{sxr_version} scalacheck = %{scalacheck_version} +BuildRequires: specs2 = %{specs2_version} +%endif + +%endif + +%description +sbt is the simple build tool for Scala and Java projects. + +%prep +%setup -q -n %{name}-%{sbt_version}%{sbt_build} + +%patch0 -p1 +%patch1 -p1 +%patch2 -p1 +%patch3 -p1 + +%if !%{do_proper} +%patch4 -p1 +%endif + +%patch5 + +sed -i -e '/% "test"/d' project/Util.scala + +cp %{SOURCE16} . +cp %{SOURCE15} . +chmod 755 climbing-nemesis.py + +cp %{SOURCE17} . + +%if %{do_bootstrap} +cp %{SOURCE63} . +%endif + +sed -i -e '/dispatch-http/d' project/p.sbt +sed -i -e '/sbt-site/d' project/p.sbt +sed -i -e '/sbt-ghpages/d' project/p.sbt + + +sed -i -e 's/0.7.1/0.6.2/g' project/p.sbt + +for props in rpmbuild-sbt.boot.properties sbt.boot.properties ; do + sed -i -e 's/FEDORA_SCALA_VERSION/%{scala_version}/g' $props + sed -i -e 's/FEDORA_SBT_VERSION/%{sbt_version}/g' $props +done + +sed -i -e 's/0.13.0/%{sbt_bootstrap_version}/g' project/build.properties + +###################################################################### +# Here we're going to use the climbing-nemesis script to populate a local +# Ivy repository. sbt needs these dependencies to be resolvable by Ivy +# and not merely on the classpath. When we build a package, we'll be taking +# this repository and installing it alongside the sbt jars so our sbt binary +# can use it. +###################################################################### + +./climbing-nemesis.py org.jsoup jsoup %{ivy_local_dir} --version 1.7.1 + +./climbing-nemesis.py com.jcraft jsch %{ivy_local_dir} --version 0.1.46 + +# scala compiler; nb; we may need to treat the compiler specially to remove the spurious jline dependency +./climbing-nemesis.py org.scala-lang scala-library %{ivy_local_dir} --version %{scala_version} +./climbing-nemesis.py org.scala-lang scala-compiler %{ivy_local_dir} --version %{scala_version} +./climbing-nemesis.py org.scala-lang scala-reflect %{ivy_local_dir} --version %{scala_version} + +./climbing-nemesis.py jline jline %{ivy_local_dir} --version 2.11 +./climbing-nemesis.py org.fusesource.jansi jansi %{ivy_local_dir} --version 1.12 +./climbing-nemesis.py org.fusesource.jansi jansi-native %{ivy_local_dir} --version 1.8 +./climbing-nemesis.py org.fusesource.hawtjni hawtjni-runtime %{ivy_local_dir} --version 1.16 + +%if %{do_bootstrap} +# we need to use the bundled ivy in the bootstrap build because 2.3.0 +# is source and binary incompatible with 2.3.0-rc1 (which upstream sbt +# 0.13.1 is built against) + +./climbing-nemesis.py org.apache.ivy ivy %{ivy_local_dir} --version 2.3.0-rc1 --pomfile %{SOURCE18} --jarfile %{SOURCE19} # --extra-dep org.bouncycastle:bcpg-jdk16:1.46 --extra-dep org.bouncycastle:bcprov-jdk16:1.46 +%endif + +# we're building against Ivy 2.3.0, though +./climbing-nemesis.py org.apache.ivy ivy %{ivy_local_dir} --version 2.3.0 --pomfile %{SOURCE20} --jarfile %{_javadir}/ivy.jar # --extra-dep org.bouncycastle:bcpg-jdk16:1.46 --extra-dep org.bouncycastle:bcprov-jdk16:1.46 + +## BEGIN OPTIONAL IVY DEPS + +# bouncycastle pgp signature generator +# ./climbing-nemesis.py org.bouncycastle bcpg-jdk16 %{ivy_local_dir} --version 1.46 +# ./climbing-nemesis.py org.bouncycastle bcprov-jdk16 %{ivy_local_dir} --version 1.46 + +# ORO (blast from the past) +./climbing-nemesis.py oro oro %{ivy_local_dir} --version 2.0.8 + +# JSCH +./climbing-nemesis.py com.jcraft jsch %{ivy_local_dir} --version 0.1.31 + +# commons-httpclient +./climbing-nemesis.py commons-httpclient commons-httpclient %{ivy_local_dir} --version 3.0 + +## END OPTIONAL IVY DEPS + +./climbing-nemesis.py net.sf.proguard proguard-base %{ivy_local_dir} --version 4.8 --jarfile %{_javadir}/proguard/proguard.jar + +%if %{do_bootstrap} +cp %{SOURCE132} org.scala-sbt.ivy-%{sbt_bootstrap_version}.ivy.xml +cp %{SOURCE171} org.scala-sbt.sbt-%{sbt_bootstrap_version}.ivy.xml + +sed -i -e '/precompiled/d' org.scala-sbt.ivy-%{sbt_bootstrap_version}.ivy.xml +sed -i -e '/precompiled/d' org.scala-sbt.sbt-%{sbt_bootstrap_version}.ivy.xml + +./climbing-nemesis.py --jarfile %{SOURCE32} --ivyfile org.scala-sbt.ivy-%{sbt_bootstrap_version}.ivy.xml org.scala-sbt ivy %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE33} --ivyfile %{SOURCE133} org.scala-sbt task-system %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE34} --ivyfile %{SOURCE134} org.scala-sbt compiler-interface-src %{ivy_local_dir} --version %{sbt_bootstrap_version} --override org.scala-sbt:compiler-interface --override-dir-only +./climbing-nemesis.py --jarfile %{SOURCE35} --ivyfile %{SOURCE135} org.scala-sbt compiler-interface-bin %{ivy_local_dir} --version %{sbt_bootstrap_version} --override org.scala-sbt:compiler-interface --override-dir-only +./climbing-nemesis.py --jarfile %{SOURCE36} --ivyfile %{SOURCE136} org.scala-sbt testing %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE37} --ivyfile %{SOURCE137} org.scala-sbt command %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE38} --ivyfile %{SOURCE138} org.scala-sbt test-agent %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE39} --ivyfile %{SOURCE139} org.scala-sbt launcher-interface %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE40} --ivyfile %{SOURCE140} org.scala-sbt run %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE41} --ivyfile %{SOURCE141} org.scala-sbt compiler-ivy-integration %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE42} --ivyfile %{SOURCE142} org.scala-sbt scripted-sbt %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE44} --ivyfile %{SOURCE144} org.scala-sbt collections %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE45} --ivyfile %{SOURCE145} org.scala-sbt persist %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE46} --ivyfile %{SOURCE146} org.scala-sbt classfile %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE47} --ivyfile %{SOURCE147} org.scala-sbt control %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE48} --ivyfile %{SOURCE148} org.scala-sbt launcher %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE49} --ivyfile %{SOURCE149} org.scala-sbt apply-macro %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE50} --ivyfile %{SOURCE150} org.scala-sbt datatype-generator %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE51} --ivyfile %{SOURCE151} org.scala-sbt interface %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE52} --ivyfile %{SOURCE152} org.scala-sbt main-settings %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE53} --ivyfile %{SOURCE153} org.scala-sbt incremental-compiler %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE54} --ivyfile %{SOURCE154} org.scala-sbt cache %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE55} --ivyfile %{SOURCE155} org.scala-sbt compiler-integration %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE56} --ivyfile %{SOURCE156} org.scala-sbt api %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE57} --ivyfile %{SOURCE157} org.scala-sbt main %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE58} --ivyfile %{SOURCE158} org.scala-sbt classpath %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE59} --ivyfile %{SOURCE159} org.scala-sbt logging %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE60} --ivyfile %{SOURCE160} org.scala-sbt compile %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE61} --ivyfile %{SOURCE161} org.scala-sbt process %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE62} --ivyfile %{SOURCE162} org.scala-sbt actions %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE63} --ivyfile %{SOURCE163} org.scala-sbt sbt-launch %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE64} --ivyfile %{SOURCE164} org.scala-sbt scripted-plugin %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE65} --ivyfile %{SOURCE165} org.scala-sbt tracking %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE66} --ivyfile %{SOURCE166} org.scala-sbt tasks %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE67} --ivyfile %{SOURCE167} org.scala-sbt completion %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE68} --ivyfile %{SOURCE168} org.scala-sbt cross %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE69} --ivyfile %{SOURCE169} org.scala-sbt relation %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE70} --ivyfile %{SOURCE170} org.scala-sbt io %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE71} --ivyfile org.scala-sbt.sbt-%{sbt_bootstrap_version}.ivy.xml org.scala-sbt sbt %{ivy_local_dir} --version %{sbt_bootstrap_version} +./climbing-nemesis.py --jarfile %{SOURCE72} --ivyfile %{SOURCE172} org.scala-sbt scripted-framework %{ivy_local_dir} --version %{sbt_bootstrap_version} + +# plugins + +./climbing-nemesis.py --jarfile %{SOURCE73} com.typesafe.sbt sbt-ghpages %{ivy_local_dir} --version %{sbt_ghpages_version} --meta e:scalaVersion=%{scala_short_version} --meta e:sbtVersion=%{sbt_short_version} +./climbing-nemesis.py --jarfile %{SOURCE74} com.typesafe.sbt sbt-site %{ivy_local_dir} --version %{sbt_site_version} --meta e:scalaVersion=%{scala_short_version} --meta e:sbtVersion=%{sbt_short_version} +./climbing-nemesis.py --jarfile %{SOURCE75} com.typesafe.sbt sbt-git %{ivy_local_dir} --version %{sbt_git_version} --meta e:scalaVersion=%{scala_short_version} --meta e:sbtVersion=%{sbt_short_version} + +# SXR +%if %{?want_sxr} +./climbing-nemesis.py --jarfile %{SOURCE76} org.scala-sbt.sxr sxr %{ivy_local_dir} --version %{sxr_version} --scala %{scala_short_version} +%endif + +# test-interface +./climbing-nemesis.py org.scala-sbt test-interface %{ivy_local_dir} --version 1.0 + +# sbinary +./climbing-nemesis.py org.scala-tools.sbinary sbinary_%{scala_short_version} %{ivy_local_dir} # --scala %{scala_short_version} + +# scalacheck +%if %{?want_scalacheck} +./climbing-nemesis.py --jarfile %{SOURCE78} org.scalacheck scalacheck %{ivy_local_dir} --version %{scalacheck_version} --scala %{scala_short_version} +%endif + +# specs2 +%if %{?want_specs2} +./climbing-nemesis.py --jarfile %{SOURCE79} org.specs2 specs2 %{ivy_local_dir} --version %{specs2_version} --scala %{scala_short_version} +%endif + +%if %{?want_dispatch_http} +# dispatch-http +./climbing-nemesis.py --jarfile %{SOURCE81} net.databinder dispatch-http_%{scala_short_version} %{ivy_local_dir} --version %{dispatch_http_version} +%endif + +%else +# If we aren't bootstrapping, copy installed jars into local ivy cache +# dir. In the future, we'll use MikoĊ‚aj's new xmvn Ivy resolver. + +# sbt components +for jar in actions api apply-macro cache classfile classpath collections command compile compiler-integration compiler-ivy-integration completion control cross datatype-generator incremental-compiler interface io ivy launcher launcher-interface logging main main-settings persist process relation run sbt scripted-framework scripted-plugin scripted-sbt tasks task-system test-agent testing tracking; do + ./climbing-nemesis.py --jarfile %{_javadir}/%{name}/${jar}.jar --ivyfile %{installed_ivy_local}/org.scala-sbt/${jar}/%{sbt_bootstrap_version}/ivy.xml org.scala-sbt ${jar} %{ivy_local_dir} +done + +./climbing-nemesis.py --jarfile %{_javadir}/%{name}/compiler-interface-src.jar --ivyfile %{installed_ivy_local}/org.scala-sbt/compiler-interface/%{sbt_bootstrap_version}/ivy.xml org.scala-sbt compiler-interface-src %{ivy_local_dir} --version %{sbt_bootstrap_version} --override org.scala-sbt:compiler-interface --override-dir-only + +./climbing-nemesis.py --jarfile %{_javadir}/%{name}/compiler-interface-bin.jar --ivyfile %{installed_ivy_local}/org.scala-sbt/compiler-interface/%{sbt_bootstrap_version}/ivy.xml org.scala-sbt compiler-interface-bin %{ivy_local_dir} --version %{sbt_bootstrap_version} --override org.scala-sbt:compiler-interface --override-dir-only + +# test-interface +./climbing-nemesis.py org.scala-sbt test-interface %{ivy_local_dir} --version 1.0 + +# sbinary +./climbing-nemesis.py org.scala-tools.sbinary sbinary_%{scala_short_version} %{ivy_local_dir} # --scala %{scala_short_version} + +%endif + +# better not to try and compile the docs project +rm -f project/Docs.scala + +mkdir sbt-boot-dir + +%if %{do_bootstrap} +mkdir -p sbt-boot-dir/scala-%{scala_version}/org.scala-sbt/%{name}/%{sbt_bootstrap_version}/ +mkdir -p sbt-boot-dir/scala-%{scala_version}/lib + +for jar in $(find %{ivy_local_dir}/ -name \*.jar | grep fusesource) ; do + cp --symbolic-link $(readlink $jar) sbt-boot-dir/scala-%{scala_version}/lib +done + +# this is a hack, obvs +for jar in $(find %{ivy_local_dir}/ -name \*.jar | grep bouncycastle) ; do + cp --symbolic-link $(readlink $jar) sbt-boot-dir/scala-%{scala_version}/lib +done + +%endif +mkdir -p scala/lib +for jar in %{_javadir}/scala/*.jar ; do + cp --symbolic-link $jar scala/lib +done + +sed -i -e 's/["]2[.]10[.][234]["]/\"%{scala_version}\"/g' $(find . -name \*.sbt -type f) $(find . -name \*.xml) $(find . -name \*.scala) +sed -i -e 's/["]2[.]10[.]2-RC2["]/\"%{scala_version}\"/g' $(find . -name \*.sbt -type f) + +# work around proguard bugs with the Scala library +sed -i -e 's/"-dontnote",/"-dontnote", "-dontshrink", "-dontoptimize",/g' project/Proguard.scala +sed -i -e 's/mapLibraryJars.all filterNot in[.]toSet./mapLibraryJars(all.map {f => new java.io.File(f.getCanonicalPath())} filterNot in.map {f => new java.io.File(f.getCanonicalPath())}.toSet)/g' project/Proguard.scala + +%build + +export SBT_IVY_DIR=$PWD/ivy-local +export SBT_BOOT_DIR=$PWD/sbt-boot-dir +export SBT_BOOT_PROPERTIES=rpmbuild-sbt.boot.properties +sbt package "set publishTo in Global := Some(Resolver.file(\"published\", file(\"published\"))(Resolver.ivyStylePatterns) ivys \"$(pwd)/published/[organization]/[module]/[revision]/ivy.xml\" artifacts \"$(pwd)/published/[organization]/[module]/[revision]/[artifact]-[revision].[ext]\")" publish makePom + +# XXX: this is a hack; we seem to get correct metadata but bogus JARs +# from "sbt publish" for some reason +for f in $(find published -name \*.jar ) ; do + find . -ipath \*target\* -and -name $(basename $f) -exec cp '{}' $f \; +done + +%install + +mkdir -p %{buildroot}/%{_javadir}/%{name} + +# collect and install SBT jars +find published -name \*.jar | grep -v sbt-launch.jar | grep %{sbt_full_version}.jar | xargs -I JAR cp JAR %{buildroot}/%{_javadir}/%{name} + +mkdir -p %{buildroot}/%{_bindir} +cp -p %{SOURCE21} %{buildroot}/%{_bindir}/%{name} +chmod 755 %{buildroot}/%{_bindir}/%{name} + +pushd %{buildroot}/%{_javadir}/%{name} +for jar in *.jar ; do + mv $jar $(echo $jar | sed -e 's/-%{sbt_full_version}//g') +done +popd + +rm -f %{buildroot}/%{_javadir}/%{name}/sbt-launch.jar + +mkdir -p %{buildroot}/%{_sysconfdir}/%{name} + +# XXXXXXX +for props in rpmbuild-sbt.boot.properties sbt.boot.properties ; do + sed 's/debug/info/' < $props > %{buildroot}/%{_sysconfdir}/%{name}/$props +done + +mkdir -p %{buildroot}/%{installed_ivy_local} + +# remove things that we only needed for the bootstrap build + +rm -rf %{ivy_local_dir}/net.databinder +rm -rf %{ivy_local_dir}/com.typesafe.sbt +rm -rf %{ivy_local_dir}/org.scalacheck +rm -rf %{ivy_local_dir}/org.scala-sbt.sxr +rm -rf %{ivy_local_dir}/cache + +rm -rf %{ivy_local_dir}/org.scala-sbt/sbt-launch + +(cd %{ivy_local_dir} ; tar --exclude=.md5 --exclude=.sha1 -cf - .) | (cd %{buildroot}/%{installed_ivy_local} ; tar -xf - ) +(cd published ; tar --exclude=\*.md5 --exclude=\*.sha1 -cf - .) | (cd %{buildroot}/%{installed_ivy_local} ; tar -xf - ) + +for bootjar in $(find %{buildroot}/%{installed_ivy_local}/org.scala-sbt -type l) ; do +rm -f $bootjar +ln -s %{_javadir}/%{name}/$(basename $bootjar) $bootjar +done + +%if %{do_bootstrap} +# remove bootstrap ivy 2.3.0-rc1 jar if we're using it +find %{buildroot}/%{installed_ivy_local} -lname %{SOURCE19} | xargs dirname | xargs rm -rf + +concretize() { + src=$(readlink $1) + rm $1 && cp $src $1 +} + +# copy other bootstrap dependency jars from their sources +for depjar in $(find %{buildroot}/%{installed_ivy_local} -lname %{_sourcedir}\* ) ; do +concretize $depjar +done + +%endif # do_bootstrap + +find %{buildroot}/%{installed_ivy_local} -name \*.lock -delete + +find %{buildroot}/%{_datadir}/%{name} -name \*test-interface\* | xargs rm -rf +./climbing-nemesis.py org.scala-sbt test-interface %{buildroot}/%{installed_ivy_local} --version %{testinterface_version} + +### install POM files +mkdir -p %{buildroot}/%{_mavenpomdir} +rm -f .rpm_pomfiles +touch .rpm_pomfiles +declare -a shortnames + +for pom in $(find . -name \*.pom | grep -v compiler-interface | grep -v launch-test | grep -v sbt-launch ) ; do + shortname=$(echo $pom | sed -e 's/^.*[/]\([a-z-]\+\)-0.13.1.pom$/\1/g') + echo installing POM $pom to %{_mavenpomdir}/JPP.%{name}-${shortname}.pom + cp $pom %{buildroot}/%{_mavenpomdir}/JPP.%{name}-${shortname}.pom + echo %{_mavenpomdir}/JPP.%{name}-${shortname}.pom >> .rpm_pomfiles + shortnames=( "${shortnames[@]}" $shortname ) +done + +echo shortnames are ${shortnames[@]} + +for sub in ${shortnames[@]} ; do + echo running add_maven_depmap JPP.%{name}-${sub}.pom %{name}/${sub}.jar + %add_maven_depmap JPP.%{name}-${sub}.pom %{name}/${sub}.jar +done + +%files -f .mfiles +%{_datadir}/%{name} +%{_bindir}/%{name}* +%{_javadir}/%{name} +%{_javadir}/%{name}/compiler-interface-src.jar +%{_javadir}/%{name}/compiler-interface-bin.jar + +%{_sysconfdir}/%{name} +%doc README.md LICENSE NOTICE + +%changelog +* Tue Sep 1 2020 wangxiao - %{sbt_version}-1 +- package init diff --git a/v0.13.1.tar.gz b/v0.13.1.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b9e89644c4ea6d4cfed9313c8ecff7775f20b73c Binary files /dev/null and b/v0.13.1.tar.gz differ diff --git a/v0.3.0.tar.gz b/v0.3.0.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f826389b06e418adf9a33cca766a73d86161eb55 Binary files /dev/null and b/v0.3.0.tar.gz differ diff --git a/v0.5.1.tar.gz b/v0.5.1.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7658b8ff916c27c86ce4838837b278aebc549a98 Binary files /dev/null and b/v0.5.1.tar.gz differ diff --git a/v0.6.3.tar.gz b/v0.6.3.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..27f6811e5cbab86ff9c99472d95754385b5e48df Binary files /dev/null and b/v0.6.3.tar.gz differ