def __init__(self, output, compile, main=None, libs=None, flags=None, dependencies=None, resources=None): """ @param output: the resulting .exe or .dll @param compile: the input PathSet, path or list of .cs file(s) @param main: The main class to execute if an exe is to be built. If this is set then an executable will be created. Otherwise this target will build a library. @param libs: a list of input libraries (or a PathSet) """ self.compile = FilteredPathSet(_isDotNetFile, PathSet(compile)) self.main = main self.flags = flags or [] self.libs = PathSet(libs or []) self.resources = resources or [] BaseTarget.__init__(self, output, [ self.compile, self.libs, [x for (x, y) in self.resources], dependencies or [] ]) self.tags('c#')
def __init__(self, jar, compile, classpath, manifest, options=None, package=None, preserveManifestFormatting=False): """ To add additional entries to the manifest's classpath which are needed at runtime but not during compilation, use .option('jar.manifest.classpathAppend', [...]) @param jar: path to jar to create @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; destination mapping indicates how they will appear in the manifest @param manifest: map of manifest entries, OR a string with the filename to use OR None to disable manifest generation and just produce a normal zip @param options: [DEPRECATED - use .option() instead] @param package: PathSet (or list) of other files to include in the jar; destination mapping indicates where they will appear in the jar @param preserveManifestFormatting: an advanced option that prevents the jar tool from reformatting the specified manifest file to comply with Java conventions (also prevents manifest merging if jar already exists) """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) if compile else None self.classpath = PathSet(classpath) self.package = PathSet(package) self.manifest = manifest BaseTarget.__init__(self, jar, [ self.compile, self.classpath, self.package, manifest if isinstance(manifest, basestring) else None ]) for k, v in (options or {}).items(): self.option(k, v) self.preserveManifestFormatting = preserveManifestFormatting
def __init__(self, jar, compile, classpath, manifest, options=None, package=None, preserveManifestFormatting=False): """ @param jar: path to jar to create @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; destination mapping indicates how they will appear in the manifest @param manifest: map of manifest entries, OR a string with the filename to use OR None to disable manifest generation and just produce a normal zip @param options: generic target options map @param package: PathSet (or list) of other files to include in the jar; destination mapping indicates where they will appear in the jar @param preserveManifestFormatting: an advanced option that prevents the jar tool from reformatting the specified manifest file to comply with Java conventions (also prevents manifest merging if jar already exists) """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) if compile else None self.classpath = PathSet(classpath) self.package = PathSet(package) self.manifest = manifest BaseTarget.__init__(self, jar, [self.compile,self.classpath,self.package, manifest if isinstance(manifest, basestring) else None]) self.options = options self.preserveManifestFormatting = preserveManifestFormatting
def __init__(self, output, compile, classpath, options=None): """ @param output: output dir for class files @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; @param options: [DEPRECATED - use .option() instead] """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) self.classpath = PathSet(classpath) BaseTarget.__init__(self, output, [self.compile, self.classpath]) for k, v in (options or {}).items(): self.option(k, v)
class Javac(BaseTarget): """ Compile java source to a directory (without jarring it) """ compile = None classpath = None def __init__(self, output, compile, classpath, options=None): """ @param output: output dir for class files @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; @param options: [DEPRECATED - use .option() instead] """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) self.classpath = PathSet(classpath) BaseTarget.__init__(self, output, [self.compile, self.classpath]) for k, v in (options or {}).items(): self.option(k, v) def run(self, context): # make sure outputdir exists mkdir(self.path) # create the classpath, sorting within PathSet (for determinism), but retaining original order of # PathSet elements in the list classpath = os.pathsep.join(self.classpath.resolve(context)) # compile everything mkdir(self.getOption('javac.logs')) javac(self.path, self.compile.resolve(context), classpath, options=self.options, logbasename=self.options['javac.logs'] + '/' + targetNameToUniqueId(self.name), targetname=self.name) def getHashableImplicitInputs(self, context): # changes in the manifest text should cause a rebuild # for now, don't bother factoring global jar.manifest.defaults option # in here (it'll almost never change anyway) return super(Javac, self).getHashableImplicitInputs(context) + sorted([ 'option: %s = "%s"' % (k, v) for (k, v) in self.options.items() if v and (k.startswith('javac.') or k == 'java.home') ])
class CSharp(BaseTarget): """ Compile C# files to an executable or dll """ compile = None main = None libs = None def __init__(self, output, compile, main=None, libs=None, flags=None, dependencies=None, resources=None): """ @param output: the resulting .exe or .dll @param compile: the input PathSet, path or list of .cs file(s) @param main: The main class to execute if an exe is to be built. If this is set then an executable will be created. Otherwise this target will build a library. @param libs: a list of input libraries (or a PathSet) """ self.compile = FilteredPathSet(_isDotNetFile, PathSet(compile)) self.main = main self.flags = flags or [] self.libs = PathSet(libs or []) self.resources = resources or [] BaseTarget.__init__(self, output, [self.compile, self.libs, [x for (x, y) in self.resources], dependencies or []]) self.tags('c#') def getHashableImplicitInputs(self, context): return super(CSharp, self).getHashableImplicitInputs(context) + (['main = %s'%context.expandPropertyValues(('%s'%self.main))] if self.main else []) def run(self, context): options = context.mergeOptions(self) # get the merged options libs = self.libs.resolve(context) libnames = map(lambda x:os.path.basename(x), libs) libpaths = map(lambda x:os.path.dirname(x), libs) flags = [context.expandPropertyValues(x) for x in self.flags] args = [options['csharp.compiler'], "-out:"+self.path] if libnames: args.extend(["-reference:"+",".join(libnames), "-lib:"+",".join(libpaths)]) if self.main: args.extend(["-target:exe", "-main:"+self.main]) else: args.append("-target:library") for (file, id) in self.resources: args.append('-resource:%s,%s' % (context.expandPropertyValues(file), context.expandPropertyValues(id))) args.extend(options['csharp.options']) args.extend(flags) args.extend(self.compile.resolve(context)) mkdir(os.path.dirname(self.path)) call(args, outputHandler=options['csharp.processoutputhandler']('csc', False, options=options), timeout=options['process.timeout'])
class CSharp(BaseTarget): """ Compile C# files to an executable or dll """ compile = None main = None libs = None def __init__(self, output, compile, main=None, libs=None, flags=None, dependencies=None, resources=None): """ @param output: the resulting .exe or .dll @param compile: the input PathSet, path or list of .cs file(s) @param main: The main class to execute if an exe is to be built. If this is set then an executable will be created. Otherwise this target will build a library. @param libs: a list of input libraries (or a PathSet) """ self.compile = FilteredPathSet(_isDotNetFile, PathSet(compile)) self.main = main self.flags = flags or [] self.libs = PathSet(libs or []) self.resources = resources or [] BaseTarget.__init__(self, output, [self.compile, self.libs, [x for (x, y) in self.resources], dependencies or []]) self.tags('c#') def getHashableImplicitInputs(self, context): return super(CSharp, self).getHashableImplicitInputs(context) + (['main = %s'%context.expandPropertyValues(('%s'%self.main))] if self.main else []) def run(self, context): libs = self.libs.resolve(context) libnames = map(lambda x:os.path.basename(x), libs) libpaths = map(lambda x:os.path.dirname(x), libs) flags = [context.expandPropertyValues(x) for x in self.flags] args = [self.getOption('csharp.compiler'), "-out:"+self.path] if libnames: args.extend(["-reference:"+",".join(libnames), "-lib:"+",".join(libpaths)]) if self.main: args.extend(["-target:exe", "-main:"+self.main]) else: args.append("-target:library") for (file, id) in self.resources: args.append('-resource:%s,%s' % (context.expandPropertyValues(file), context.expandPropertyValues(id))) args.extend(self.options['csharp.options']) args.extend(flags) args.extend(self.compile.resolve(context)) mkdir(os.path.dirname(self.path)) call(args, outputHandler=self.getOption('csharp.processoutputhandler')('csc', False, options=self.options), timeout=self.options['process.timeout'])
def __init__(self, output, compile, classpath, options=None): """ @param output: output dir for class files @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; @param options: generic target options map for passing options to the underlying operation (optional) """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) self.classpath = PathSet(classpath) BaseTarget.__init__(self, output, [self.compile,self.classpath]) self.options = options
class Javac(BaseTarget): """ Compile java source to a directory (without jarring it) """ compile = None classpath = None def __init__(self, output, compile, classpath, options=None): """ @param output: output dir for class files @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; @param options: generic target options map for passing options to the underlying operation (optional) """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) self.classpath = PathSet(classpath) BaseTarget.__init__(self, output, [self.compile,self.classpath]) self.options = options def run(self, context): options = context.mergeOptions(self) # get the merged options # make sure outputdir exists mkdir(self.path) # create the classpath, sorting within PathSet (for determinism), but retaining original order of # PathSet elements in the list classpath = os.pathsep.join(self.classpath.resolve(context)) # compile everything mkdir(options.get('javac.logs')) javac(self.path, self.compile.resolve(context), classpath, options=options, logbasename=options.get('javac.logs')+'/'+targetNameToUniqueId(self.name), targetname=self.name) def getHashableImplicitInputs(self, context): # changes in the manifest text should cause a rebuild # for now, don't bother factoring global jar.manifest.defaults option # in here (it'll almost never change anyway) return super(Javac, self).getHashableImplicitInputs(context) + sorted([ 'option: %s = "%s"'%(k,v) for (k,v) in context.mergeOptions(self).items() if v and (k.startswith('javac.') or k == 'java.home')])
def __init__(self, output, compile, main=None, libs=None, flags=None, dependencies=None, resources=None): """ @param output: the resulting .exe or .dll @param compile: the input PathSet, path or list of .cs file(s) @param main: The main class to execute if an exe is to be built. If this is set then an executable will be created. Otherwise this target will build a library. @param libs: a list of input libraries (or a PathSet) """ self.compile = FilteredPathSet(_isDotNetFile, PathSet(compile)) self.main = main self.flags = flags or [] self.libs = PathSet(libs or []) self.resources = resources or [] BaseTarget.__init__(self, output, [self.compile, self.libs, [x for (x, y) in self.resources], dependencies or []]) self.tags('c#')
class Jar(BaseTarget): """ Create a Jar, first compiling some java, then packing it all up """ compile = None classpath = None package = None manifest = None def __init__(self, jar, compile, classpath, manifest, options=None, package=None, preserveManifestFormatting=False): """ To add additional entries to the manifest's classpath which are needed at runtime but not during compilation, use .option('jar.manifest.classpathAppend', [...]) @param jar: path to jar to create @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; destination mapping indicates how they will appear in the manifest @param manifest: map of manifest entries, OR a string with the filename to use OR None to disable manifest generation and just produce a normal zip @param options: [DEPRECATED - use .option() instead] @param package: PathSet (or list) of other files to include in the jar; destination mapping indicates where they will appear in the jar @param preserveManifestFormatting: an advanced option that prevents the jar tool from reformatting the specified manifest file to comply with Java conventions (also prevents manifest merging if jar already exists) """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) if compile else None self.classpath = PathSet(classpath) self.package = PathSet(package) self.manifest = manifest BaseTarget.__init__(self, jar, [ self.compile, self.classpath, self.package, manifest if isinstance(manifest, basestring) else None ]) for k, v in (options or {}).items(): self.option(k, v) self.preserveManifestFormatting = preserveManifestFormatting def run(self, context): options = self.options # make sure temp dir exists mkdir(self.workDir) classes = os.path.join(self.workDir, "classes") # output dir for classes # create the classpath, sorting within PathSet (for determinism), but retaining original order of # PathSet elements in the list classpath = os.pathsep.join(self.classpath.resolve(context)) # compile everything mkdir( classes ) # (need this for assembling other files to package later on, even if we don't do any javac) if self.compile: mkdir(self.getOption('javac.logs')) javac(classes, self.compile.resolve(context), classpath, options=options, logbasename=options.get('javac.logs') + '/' + targetNameToUniqueId(self.name), targetname=self.name) manifest = os.path.join(self.workDir, "MANIFEST.MF") # manifest file if isinstance(self.manifest, basestring): manifest = context.getFullPath(self.manifest, self.baseDir) elif self.manifest == None: manifest = None else: # generate one # rewrite property values in the manifest manifest_entries = {} for i in self.manifest: manifest_entries[i] = context.expandPropertyValues( self.manifest[i]) # determine classpath for manifest classpath_entries = [] if "Class-path" not in manifest_entries: # assuming it wasn't hardcoded, set it here for src, dest in self.classpath.resolveWithDestinations( context): # we definitely do want to support use of ".." in destinations here, it can be very useful classpath_entries.append(dest) assert isinstance( options['jar.manifest.classpathAppend'], list), options[ 'jar.manifest.classpathAppend'] # must not be a string classpath_entries.extend( options['jar.manifest.classpathAppend'] or []) # need to always use / not \ for these to be valid classpath_entries = [ p.replace(os.path.sep, '/').replace('\\', '/') for p in classpath_entries if p ] if classpath_entries: manifest_entries["Class-path"] = " ".join( classpath_entries) # include the classpath from here if not manifest_entries.get( 'Class-path' ): # suppress this element entirely if not needed, otherwise there would be no way to have an empty classpath manifest_entries.pop('Class-path', '') # create the manifest file create_manifest(manifest, manifest_entries, options=options) # copy in the additional things to include for (src, dest) in self.package.resolveWithDestinations(context): if '..' in dest: raise Exception( 'This target does not permit packaged destination paths to contain ".." relative path expressions' ) mkdir(os.path.dirname(os.path.join(classes, dest))) destpath = normLongPath(classes + '/' + dest) srcpath = normLongPath(src) if os.path.isdir(srcpath): mkdir(destpath) else: with open(srcpath, 'rb') as s: with openForWrite(destpath, 'wb') as d: d.write(s.read()) # create the jar jar(self.path, manifest, classes, options=options, preserveManifestFormatting=self.preserveManifestFormatting, outputHandler=ProcessOutputHandler('jar', treatStdErrAsErrors=False, options=options)) def getHashableImplicitInputs(self, context): # changes in the manifest text should cause a rebuild # for now, don't bother factoring global jar.manifest.defaults option # in here (it'll almost never change anyway) return super(Jar, self).getHashableImplicitInputs(context) + [ 'manifest = '+context.expandPropertyValues(str(self.manifest)), 'classpath = '+context.expandPropertyValues(str(self.classpath)), # because classpath destinations affect manifest ]+(['preserveManifestFormatting = true'] if self.preserveManifestFormatting else [])\ +sorted(['option: %s = "%s"'%(k,v) for (k,v) in self.options.items() if v and (k.startswith('javac.') or k.startswith('jar.') or k == 'java.home')])
class Jar(BaseTarget): """ Create a Jar, first compiling some java, then packing it all up """ compile = None classpath = None package = None manifest = None def __init__(self, jar, compile, classpath, manifest, options=None, package=None, preserveManifestFormatting=False): """ @param jar: path to jar to create @param compile: PathSet (or list) of things to compile @param classpath: PathSet (or list) of things to be on the classpath; destination mapping indicates how they will appear in the manifest @param manifest: map of manifest entries, OR a string with the filename to use OR None to disable manifest generation and just produce a normal zip @param options: generic target options map @param package: PathSet (or list) of other files to include in the jar; destination mapping indicates where they will appear in the jar @param preserveManifestFormatting: an advanced option that prevents the jar tool from reformatting the specified manifest file to comply with Java conventions (also prevents manifest merging if jar already exists) """ self.compile = FilteredPathSet(_isJavaFile, PathSet(compile)) if compile else None self.classpath = PathSet(classpath) self.package = PathSet(package) self.manifest = manifest BaseTarget.__init__(self, jar, [self.compile,self.classpath,self.package, manifest if isinstance(manifest, basestring) else None]) self.options = options self.preserveManifestFormatting = preserveManifestFormatting def run(self, context): options = context.mergeOptions(self) # get the merged options # make sure temp dir exists mkdir(self.workDir) classes = os.path.join(self.workDir, "classes") # output dir for classes # create the classpath, sorting within PathSet (for determinism), but retaining original order of # PathSet elements in the list classpath = os.pathsep.join(self.classpath.resolve(context)) # compile everything mkdir(classes) # (need this for assembling other files to package later on, even if we don't do any javac) if self.compile: mkdir(options.get('javac.logs')) javac(classes, self.compile.resolve(context), classpath, options=options, logbasename=options.get('javac.logs')+'/'+targetNameToUniqueId(self.name), targetname=self.name) manifest = os.path.join(self.workDir, "MANIFEST.MF") # manifest file if isinstance(self.manifest, basestring): manifest = context.getFullPath(self.manifest, self.baseDir) elif self.manifest == None: manifest = None else: # generate one # rewrite property values in the manifest manifest_entries = {} for i in self.manifest: manifest_entries[i] = context.expandPropertyValues(self.manifest[i]) # determine classpath for manifest classpath_entries = [] if "Class-path" not in manifest_entries: # assuming it wasn't hardcoded, set it here for src, dest in self.classpath.resolveWithDestinations(context): classpath_entries.append(dest) assert isinstance(options['jar.manifest.classpathAppend'], list), options['jar.manifest.classpathAppend'] # must not be a string classpath_entries.extend(options['jar.manifest.classpathAppend'] or []) # need to always use / not \ for these to be valid classpath_entries = [p.replace(os.path.sep, '/').replace('\\', '/') for p in classpath_entries if p] if classpath_entries: manifest_entries["Class-path"] = " ".join(classpath_entries) # include the classpath from here if not manifest_entries.get('Class-path'): # suppress this element entirely if not needed, otherwise there would be no way to have an empty classpath manifest_entries.pop('Class-path','') # create the manifest file create_manifest(manifest, manifest_entries, options=options) # copy in the additional things to include for (src, dest) in self.package.resolveWithDestinations(context): mkdir(os.path.dirname(os.path.join(classes, dest))) destpath = normLongPath(classes+'/'+dest) srcpath = normLongPath(src) if os.path.isdir(srcpath): mkdir(destpath) else: with open(srcpath, 'rb') as s: with openForWrite(destpath, 'wb') as d: d.write(s.read()) # create the jar jar(self.path, manifest, classes, options=options, preserveManifestFormatting=self.preserveManifestFormatting, outputHandler=ProcessOutputHandler('jar', treatStdErrAsErrors=False,options=options)) def getHashableImplicitInputs(self, context): # changes in the manifest text should cause a rebuild # for now, don't bother factoring global jar.manifest.defaults option # in here (it'll almost never change anyway) return super(Jar, self).getHashableImplicitInputs(context) + [ 'manifest = '+context.expandPropertyValues(str(self.manifest)), 'classpath = '+context.expandPropertyValues(str(self.classpath)), # because classpath destinations affect manifest ]+(['preserveManifestFormatting = true'] if self.preserveManifestFormatting else [])\ +sorted(['option: %s = "%s"'%(k,v) for (k,v) in context.mergeOptions(self).items() if v and (k.startswith('javac.') or k.startswith('jar.') or k == 'java.home')])