commit 9383b97d4d353adfe0c4dde61b8f0b5aa19b9d83 Author: slava86 Date: Thu Jun 25 12:42:48 2020 +0300 Imported from SRPM diff --git a/.abf.yml b/.abf.yml new file mode 100644 index 0000000..d085abd --- /dev/null +++ b/.abf.yml @@ -0,0 +1,9 @@ +sources: + 0.6.2.tar.gz: 0abce7993c4ddaa434959b48bbd13bbcc4845b67 + 1.11.0.tar.gz: e224b1ddd3e060d2565c009f3c66fb3259d8c77e + SPECS2-1.12.3.tar.gz: 695ce8fd7d78304f2e0cb5511b22dfdd0037e038 + ivy-2.3.0-rc1.jar: 47fc7fbbfd2558245c166ca5105d60d86eb6699e + v0.13.1.tar.gz: f9dfc9f8cb2d3ab1b0a35c34e8f93e2660bd5093 + v0.3.0.tar.gz: 620ec4d63403f95aaed52ae3507e7224cab26bbc + v0.5.1.tar.gz: 72cbd186a6f6a7c9a4d6adf9463b525649933973 + v0.6.3.tar.gz: 2aaf75542295eebe4348945f881342b3fdf8ea3c diff --git a/climbing-nemesis.py b/climbing-nemesis.py new file mode 100644 index 0000000..a5c85fe --- /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.pom b/ivy-2.3.0-rc1.pom new file mode 100644 index 0000000..e540e4f --- /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 0000000..1212775 --- /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 0000000..67501fb --- /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 100755 index 0000000..ed3d026 --- /dev/null +++ b/sbt @@ -0,0 +1,28 @@ +#!/bin/sh + +relpkg=$(rpm -q --whatprovides redhat-release | head -1) +relver=$(rpm -q --queryformat '%{version}' $relpkg) +case "$relpkg" in +fedora* ) fedora=${relver%%[^0-9]*} rhel= ;; +* ) rhel=${relver%%[^0-9]*} fedora= ;; +esac + +if \[ 0$fedora -ge 21 -o 0$rhel -gt 7 \] ; then +export JLINE=jline +else +export JLINE=jline2 +fi + +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-RC3-release-scala.patch b/sbt-0.13.1-RC3-release-scala.patch new file mode 100644 index 0000000..caa8175 --- /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 0000000..40bd7cd --- /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 0000000..98d5c80 --- /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 0000000..133cc9e --- /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 0000000..7fb5f12 --- /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 0000000..efb4026 --- /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 0000000..8a8d83d --- /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 0000000..5480637 --- /dev/null +++ b/sbt.spec @@ -0,0 +1,784 @@ +# doing a bootstrap build from public sbt binaries +# bootstrap exception is here: https://fedorahosted.org/fpc/ticket/389 +# meeting minutes with vote are here: http://meetbot.fedoraproject.org/fedora-meeting-1/2014-02-13/fpc.2014-02-13-17.00.html + +%global do_bootstrap 0 + +# build non-bootstrap packages with tests, cross-referenced sources, etc +%global do_proper 0 +%global pkg_rel 9 +%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: %{pkg_rel}%{?dist}.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 + +%if %{do_bootstrap} +# include bootstrap libraries + +Source32: %sbt_ivy_artifact ivy + +Source132: %sbt_ivy_descriptor ivy + +Source33: %sbt_ivy_artifact task-system + +Source133: %sbt_ivy_descriptor task-system + +Source34: %generic_ivy_artifact %{typesafe_repo} org.scala-sbt compiler-interface %{sbt_bootstrap_version} compiler-interface-src + +Source134: %generic_ivy_descriptor %{typesafe_repo} org.scala-sbt compiler-interface %{sbt_bootstrap_version} compiler-interface-src + +Source35: %generic_ivy_artifact %{typesafe_repo} org.scala-sbt compiler-interface %{sbt_bootstrap_version} compiler-interface-bin + +Source135: %generic_ivy_descriptor %{typesafe_repo} org.scala-sbt compiler-interface %{sbt_bootstrap_version} compiler-interface-bin + +Source36: %sbt_ivy_artifact testing + +Source136: %sbt_ivy_descriptor testing + +Source37: %sbt_ivy_artifact command + +Source137: %sbt_ivy_descriptor command + +Source38: %sbt_ivy_artifact test-agent + +Source138: %sbt_ivy_descriptor test-agent + +Source39: %sbt_ivy_artifact launcher-interface + +Source139: %sbt_ivy_descriptor launcher-interface + +Source40: %sbt_ivy_artifact run + +Source140: %sbt_ivy_descriptor run + +Source41: %sbt_ivy_artifact compiler-ivy-integration + +Source141: %sbt_ivy_descriptor compiler-ivy-integration + +Source42: %sbt_ivy_artifact scripted-sbt + +Source142: %sbt_ivy_descriptor scripted-sbt + +Source44: %sbt_ivy_artifact collections + +Source144: %sbt_ivy_descriptor collections + +Source45: %sbt_ivy_artifact persist + +Source145: %sbt_ivy_descriptor persist + +Source46: %sbt_ivy_artifact classfile + +Source146: %sbt_ivy_descriptor classfile + +Source47: %sbt_ivy_artifact control + +Source147: %sbt_ivy_descriptor control + +Source48: %sbt_ivy_artifact launcher + +Source148: %sbt_ivy_descriptor launcher + +Source49: %sbt_ivy_artifact apply-macro + +Source149: %sbt_ivy_descriptor apply-macro + +Source50: %sbt_ivy_artifact datatype-generator + +Source150: %sbt_ivy_descriptor datatype-generator + +Source51: %sbt_ivy_artifact interface + +Source151: %sbt_ivy_descriptor interface + +Source52: %sbt_ivy_artifact main-settings + +Source152: %sbt_ivy_descriptor main-settings + +Source53: %sbt_ivy_artifact incremental-compiler + +Source153: %sbt_ivy_descriptor incremental-compiler + +Source54: %sbt_ivy_artifact cache + +Source154: %sbt_ivy_descriptor cache + +Source55: %sbt_ivy_artifact compiler-integration + +Source155: %sbt_ivy_descriptor compiler-integration + +Source56: %sbt_ivy_artifact api + +Source156: %sbt_ivy_descriptor api + +Source57: %sbt_ivy_artifact main + +Source157: %sbt_ivy_descriptor main + +Source58: %sbt_ivy_artifact classpath + +Source158: %sbt_ivy_descriptor classpath + +Source59: %sbt_ivy_artifact logging + +Source159: %sbt_ivy_descriptor logging + +Source60: %sbt_ivy_artifact compile + +Source160: %sbt_ivy_descriptor compile + +Source61: %sbt_ivy_artifact process + +Source161: %sbt_ivy_descriptor process + +Source62: %sbt_ivy_artifact actions + +Source162: %sbt_ivy_descriptor actions + +Source63: %sbt_ivy_artifact sbt-launch + +Source163: %sbt_ivy_descriptor sbt-launch + +Source64: %sbt_ivy_artifact scripted-plugin + +Source164: %sbt_ivy_descriptor scripted-plugin + +Source65: %sbt_ivy_artifact tracking + +Source165: %sbt_ivy_descriptor tracking + +Source66: %sbt_ivy_artifact tasks + +Source166: %sbt_ivy_descriptor tasks + +Source67: %sbt_ivy_artifact completion + +Source167: %sbt_ivy_descriptor completion + +Source68: %sbt_ivy_artifact cross + +Source168: %sbt_ivy_descriptor cross + +Source69: %sbt_ivy_artifact relation + +Source169: %sbt_ivy_descriptor relation + +Source70: %sbt_ivy_artifact io + +Source170: %sbt_ivy_descriptor io + +Source71: %sbt_ivy_artifact sbt + +Source171: %sbt_ivy_descriptor sbt + +Source72: %sbt_ivy_artifact scripted-framework + +Source172: %sbt_ivy_descriptor scripted-framework + +# sbt plugins +Source73: http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases/com.typesafe.sbt/sbt-ghpages/scala_%{scala_short_version}/sbt_%{sbt_short_version}/%{sbt_ghpages_version}/jars/sbt-ghpages.jar +Source74: http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases/com.typesafe.sbt/sbt-site/scala_%{scala_short_version}/sbt_%{sbt_short_version}/%{sbt_site_jar_version}/jars/sbt-site.jar +Source75: http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases/com.typesafe.sbt/sbt-git/scala_%{scala_short_version}/sbt_%{sbt_short_version}/%{sbt_git_version}/jars/sbt-git.jar + +%if %{?want_sxr} +# sxr +Source76: http://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt.sxr/sxr_%{scala_short_version}/%{sxr_version}/jars/sxr_%{scala_short_version}.jar +%endif + +# scalacheck +%if %{?want_scalacheck} +Source78: http://oss.sonatype.org/content/repositories/releases/org/scalacheck/scalacheck_%{scala_short_version}/%{scalacheck_version}/scalacheck_%{scala_short_version}-%{scalacheck_version}.jar +%endif + +%if %{?want_specs2} +# specs +Source79: http://oss.sonatype.org/content/repositories/releases/org/specs2/specs2_%{scala_short_version}/%{specs2_version}/specs2_%{scala_short_version}-%{specs2_version}.jar +%endif + +%if %{?want_dispatch_http} +# dispatch-http +Source81: http://oss.sonatype.org/content/repositories/releases/net/databinder/dispatch-http_%{scala_short_version}/%{dispatch_http_version}/dispatch-http_%{scala_short_version}-%{dispatch_http_version}.jar +%endif + +# precompiled (need only for bootstrapping) + +Source82: http://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/precompiled-2_8_2/%{sbt_bootstrap_version}/jars/compiler-interface-bin.jar#/compiler-interface-bin-2_8_2.jar + +Source182: %sbt_ivy_descriptor precompiled-2_8_2 + +Source83: http://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/precompiled-2_9_2/%{sbt_bootstrap_version}/jars/compiler-interface-bin.jar#/compiler-interface-bin-2_9_2.jar + +Source183: %sbt_ivy_descriptor precompiled-2_9_2 + +Source84: http://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/precompiled-2_9_3/%{sbt_bootstrap_version}/jars/compiler-interface-bin.jar#/compiler-interface-bin-2_9_3.jar + +Source184: %sbt_ivy_descriptor precompiled-2_9_3 + + +%endif + +BuildRequires: mvn(org.scala-lang:scala-compiler) +BuildRequires: java-devel +BuildRequires: python +# maven is required because climbing-nemesis.py uses xmvn-resolve +BuildRequires: maven-local + +BuildRequires: mvn(org.bouncycastle:bcprov-jdk16) +BuildRequires: mvn(org.bouncycastle:bcpg-jdk16) +BuildRequires: hawtjni +BuildRequires: mvn(org.fusesource.jansi:jansi) +BuildRequires: jline2 +BuildRequires: proguard + +BuildRequires: javapackages-tools +Requires: javapackages-tools + +BuildRequires: mvn(oro:oro) +BuildRequires: mvn(com.jcraft:jsch) +BuildRequires: mvn(commons-httpclient:commons-httpclient) +BuildRequires: apache-ivy +BuildRequires: mvn(org.scala-lang:scala-compiler) +BuildRequires: mvn(org.scala-lang:scala-library) +BuildRequires: mvn(org.scala-lang:scala-reflect) +BuildRequires: mvn(org.jsoup:jsoup) + +Requires: mvn(oro:oro) +Requires: mvn(com.jcraft:jsch) +Requires: mvn(commons-httpclient:commons-httpclient) +Requires: apache-ivy +Requires: mvn(org.scala-lang:scala-compiler) +Requires: mvn(org.scala-lang:scala-library) +Requires: mvn(org.scala-lang:scala-reflect) +Requires: mvn(org.jsoup:jsoup) +Requires: proguard + +Requires: mvn(org.bouncycastle:bcprov-jdk16) +Requires: mvn(org.bouncycastle:bcpg-jdk16) +Requires: mvn(org.fusesource.jansi:jansi) +Requires: jline2 + +BuildRequires: sbinary = %{sbinary_version} +BuildRequires: test-interface = %{testinterface_version} + +Requires: sbinary = %{sbinary_version} +Requires: test-interface = %{testinterface_version} + +%if !%{do_bootstrap} +BuildRequires: sbt = %{sbt_bootstrap_version} + +%if %{do_proper} +BuildRequires: sbt-ghpages = %{sbt_ghpages_version} +BuildRequires: sbt-site = %{sbt_site_version} +BuildRequires: sbt-git = %{sbt_git_version} + +BuildRequires: sxr = %{sxr_version} +BuildRequires: 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 + +# fake on F19 +./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} + +# fake on F19 +%if 0%{?fedora} >= 21 || 0%{?rhel} > 7 +./climbing-nemesis.py jline jline %{ivy_local_dir} --version 2.11 +./climbing-nemesis.py org.fusesource.jansi jansi %{ivy_local_dir} --version 1.11 +./climbing-nemesis.py org.fusesource.jansi jansi-native %{ivy_local_dir} --version 1.7 +./climbing-nemesis.py org.fusesource.hawtjni hawtjni-runtime %{ivy_local_dir} --version 1.15 +%else +./climbing-nemesis.py jline jline %{ivy_local_dir} --version 2.11 --jarfile %{_javadir}/jline2-2.10.jar +./climbing-nemesis.py org.fusesource.jansi jansi %{ivy_local_dir} --version 1.9 +%endif + +%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 + +%if %{do_bootstrap} +java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -jar -Dfedora.sbt.ivy.dir=ivy-local -Dfedora.sbt.boot.dir=sbt-boot-dir -Divy.checksums='""' -Dsbt.boot.properties=rpmbuild-sbt.boot.properties sbt-launch.jar 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 +%else +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 +%endif + +# 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 +* Fri Feb 09 2018 Fedora Release Engineering - 0.13.1-9.1 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Tue Jan 16 2018 Merlin Mathesius 0.13.1-9 +- Manually rebase/apply earlier patch provided with BZ#1424418 to fix FTBFS: + - Thu Jun 22 2017 Troy Dawson + - Fix spec file to build with scala 2.10.6 (#1424418) +- Additional spec file FTBFS fixes to build with jansi-native 1.5 and hawtjni 1.8 +- Cleanup spec file conditionals + +* Thu Jul 27 2017 Fedora Release Engineering - 0.13.1-8.3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Sat Feb 11 2017 Fedora Release Engineering - 0.13.1-8.2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Thu Feb 04 2016 Fedora Release Engineering - 0.13.1-8.1 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Tue Jul 21 2015 Mikolaj Izdebski - 0.13.1-8 +- Non-bootstrap build + +* Tue Jul 21 2015 Mikolaj Izdebski - 0.13.1-7 +- Port to Ivy 2.4.0 +- Fix compatibility with XMvn 2.4.0 + +* Fri Jul 10 2015 William Benton - 0.13.1-7 +- bootstrap build +- fixes for Proguard +- don't ExcludeArch ARM + +* Fri Jun 19 2015 Fedora Release Engineering - 0.13.1-6.1 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Wed Apr 22 2015 Peter Robinson 0.13.1-6 +- Rebuild to fix dangling jansi-native and hawtjni-runtime symlinks + +* Sun Jun 08 2014 Fedora Release Engineering - 0.13.1-5.1 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Tue Mar 4 2014 William Benton - 0.13.1-5 +- fixes BZ 1072096 + +* Thu Jan 30 2014 William Benton - 0.13.1-4 +- use native test-interface and sbinary packages in both bootstrap and non-bootstrap modes +- fix a bug that was crashing on rawhide + +* Mon Jan 20 2014 William Benton - 0.13.1-3 +- builds as non-bootstrap package +- numerous other minor fixes + +* Wed Jan 15 2014 William Benton - 0.13.1-2 +- use generated Ivy files +- use bootstrap test-interface in bootstrap package + +* Sat Dec 14 2013 William Benton - 0.13.1-1 +- updated to 0.13.1 +- many other packaging fixes + +* Thu Nov 7 2013 William Benton - 0.13.0-1 +- initial package