def apply_haxe(self): Utils.def_attrs(self, target="", classpath="", flags="", libs="", swflib=None); classpath = Utils.to_list(self.classpath) flags = Utils.to_list(self.flags) target = self.target; inputs = [] outputs = [ self.path.get_bld().make_node(target) ] if target.endswith(".swf"): flags += ["-swf", target, "--flash-strict", "-D", "nativeTrace", "-swf-header", "640:480:60:ffffff"] if (self.swflib is not None): swflib = self.path.get_bld().make_node(self.swflib) inputs += [swflib] flags += ["-swf-lib", str(swflib)] elif target.endswith(".js"): if "-debug" in flags: outputs += [self.path.get_bld().make_node(target + ".map")] flags += ["-js", target, "--js-modern"] elif target.endswith(".n"): flags += ["-neko", target] else: raise "Unsupported target file type!" for lib in Utils.to_list(self.libs): flags += ["-lib", lib] task = self.create_task("haxe", inputs, outputs) task.classpath = classpath task.env.flags = flags self.haxe_task = task
def build_sphinx(self): """Builds sphinx sources. """ if not self.env.SPHINX_BUILD: self.bld.fatal('Program SPHINX_BUILD not defined.') if not getattr(self, 'sphinx_source', None): self.bld.fatal('Attribute sphinx_source not defined.') if not isinstance(self.sphinx_source, Node): self.sphinx_source = self.path.find_node(self.sphinx_source) if not self.sphinx_source: self.bld.fatal('Can\'t find sphinx_source: %r' % self.sphinx_source) Utils.def_attrs(self, sphinx_output_format='html') self.env.SPHINX_OUTPUT_FORMAT = self.sphinx_output_format self.env.SPHINX_OPTIONS = getattr(self, 'sphinx_options', []) for source_file in self.sphinx_source.ant_glob('**/*'): self.bld.add_manual_dependency(self.sphinx_source, source_file) sphinx_build_task = self.create_task('SphinxBuildingTask') sphinx_build_task.set_inputs(self.sphinx_source) sphinx_build_task.set_outputs(self.path.get_bld()) # the sphinx-build results are in <build + output_format> directory self.sphinx_output_directory = self.path.get_bld().make_node( self.env.SPHINX_OUTPUT_FORMAT) self.sphinx_output_directory.mkdir() Utils.def_attrs(self, install_path=get_install_path(self))
def apply_java(self): Utils.def_attrs(self,jarname='',classpath='',sourcepath='.',srcdir='.',jar_mf_attributes={},jar_mf_classpath=[]) nodes_lst=[] outdir=getattr(self,'outdir',None) if outdir: if not isinstance(outdir,Node.Node): outdir=self.path.get_bld().make_node(self.outdir) else: outdir=self.path.get_bld() outdir.mkdir() self.env['OUTDIR']=outdir.abspath() self.javac_task=tsk=self.create_task('javac') tmp=[] srcdir=getattr(self,'srcdir','') if isinstance(srcdir,Node.Node): srcdir=[srcdir] for x in Utils.to_list(srcdir): if isinstance(x,Node.Node): y=x else: y=self.path.find_dir(x) if not y: self.bld.fatal('Could not find the folder %s from %s'%(x,self.path)) tmp.append(y) tsk.srcdir=tmp if getattr(self,'compat',None): tsk.env.append_value('JAVACFLAGS',['-source',self.compat]) if hasattr(self,'sourcepath'): fold=[isinstance(x,Node.Node)and x or self.path.find_dir(x)for x in self.to_list(self.sourcepath)] names=os.pathsep.join([x.srcpath()for x in fold]) else: names=[x.srcpath()for x in tsk.srcdir] if names: tsk.env.append_value('JAVACFLAGS',['-sourcepath',names])
def apply_copy(self): Utils.def_attrs(self, fun=copy_func) self.default_install_path = 0 lst = self.to_list(self.source) self.meths.remove("process_source") for filename in lst: node = self.path.find_resource(filename) if not node: raise Errors.WafError("cannot find input file %s for processing" % filename) target = self.target if not target or len(lst) > 1: target = node.name # TODO the file path may be incorrect newnode = self.path.find_or_declare(target) tsk = self.create_task("copy", node, newnode) tsk.fun = self.fun tsk.chmod = getattr(self, "chmod", Utils.O644) if not tsk.env: tsk.debug() raise Errors.WafError("task without an environment")
def apply_java(self): Utils.def_attrs( self, jarname="", classpath="", sourcepath=".", srcdir=".", jar_mf_attributes={}, jar_mf_classpath=[] ) nodes_lst = [] if not self.classpath: if not self.env["CLASSPATH"]: self.env["CLASSPATH"] = ".." + os.pathsep + "." else: self.env["CLASSPATH"] = self.classpath if isinstance(self.srcdir, self.path.__class__): srcdir_node = self.srcdir else: srcdir_node = self.path.find_dir(self.srcdir) if not srcdir_node: raise Errors.WafError("could not find srcdir %r" % self.srcdir) self.env["OUTDIR"] = [srcdir_node.get_src().srcpath()] self.javac_task = tsk = self.create_task("javac") tsk.srcdir = srcdir_node if getattr(self, "compat", None): tsk.env.append_value("JAVACFLAGS", ["-source", self.compat]) if hasattr(self, "sourcepath"): fold = [ isinstance(x, self.path.__class__) and x or self.path.find_dir(x) for x in self.to_list(self.sourcepath) ] names = os.pathsep.join([x.srcpath() for x in fold]) else: names = srcdir_node.srcpath() if names: tsk.env.append_value("JAVACFLAGS", ["-sourcepath", names])
def init_cmd_output(self): Utils.def_attrs( self, stdin=None, stdout=None, stderr=None, # the command to execute command=None, # whether it is an external command; otherwise it is assumed # to be an executable binary or script that lives in the # source or build tree. command_is_external=False, # extra parameters (argv) to pass to the command (excluding # the command itself) argv=[], # dependencies to other objects -> this is probably not what you want (ita) # values must be 'task_gen' instances (not names!) dependencies=[], # dependencies on env variable contents dep_vars=[], # input files that are implicit, i.e. they are not # stdin, nor are they mentioned explicitly in argv hidden_inputs=[], # output files that are implicit, i.e. they are not # stdout, nor are they mentioned explicitly in argv hidden_outputs=[], # change the subprocess to this cwd (must use obj.input_dir() or output_dir() here) cwd=None, # OS environment variables to pass to the subprocess # if None, use the default environment variables unchanged os_env=None, )
def apply_haxe(self): Utils.def_attrs(self, target="", classpath="", flags="", libs="", swflib=None); classpath = Utils.to_list(self.classpath) flags = Utils.to_list(self.flags) target = self.target; inputs = [] if target.endswith(".swf"): flags += ["-swf", target, "--flash-strict", "-D", "nativeTrace"] if (self.swflib is not None): swflib = self.path.get_bld().make_node(self.swflib) inputs += [swflib] flags += ["-swf-lib", str(swflib)] elif target.endswith(".js"): flags += ["-js", target] elif target.endswith(".n"): flags += ["-neko", target] else: raise "Unsupported target file type!" for lib in Utils.to_list(self.libs): flags += ["-lib", lib] task = self.create_task("haxe", inputs, self.path.get_bld().make_node(target)) task.classpath = [self.path.find_node(cp) for cp in classpath] task.env.flags = flags self.haxe_task = task
def apply_scalac(self): Utils.def_attrs(self, jarname='', classpath='', sourcepath='.', srcdir='.', jar_mf_attributes={}, jar_mf_classpath=[]) outdir = getattr(self, 'outdir', None) if outdir: if not isinstance(outdir, Node.Node): outdir = self.path.get_bld().make_node(self.outdir) else: outdir = self.path.get_bld() outdir.mkdir() self.env['OUTDIR'] = outdir.abspath() self.scalac_task = tsk = self.create_task('scalac') tmp = [] srcdir = getattr(self, 'srcdir', '') if isinstance(srcdir, Node.Node): srcdir = [srcdir] for x in Utils.to_list(srcdir): if isinstance(x, Node.Node): y = x else: y = self.path.find_dir(x) if not y: self.bld.fatal('Could not find the folder %s from %s' % (x, self.path)) tmp.append(y) tsk.srcdir = tmp
def apply_scalac(self): Utils.def_attrs(self, jarname='', classpath='', sourcepath='.', srcdir='.', jar_mf_attributes={}, jar_mf_classpath=[]) outdir = getattr(self, 'outdir', None) if outdir: if not isinstance(outdir, Node.Node): outdir = self.path.get_bld().make_node(self.outdir) else: outdir = self.path.get_bld() outdir.mkdir() self.env['OUTDIR'] = outdir.abspath() self.scalac_task = tsk = self.create_task('scalac') tmp = [] srcdir = getattr(self, 'srcdir', '') if isinstance(srcdir, Node.Node): srcdir = [srcdir] for x in Utils.to_list(srcdir): if isinstance(x, Node.Node): y = x else: y = self.path.find_dir(x) if not y: self.bld.fatal('Could not find the folder %s from %s' % (x, self.path)) tmp.append(y) tsk.srcdir = tmp
def apply_copy(self): Utils.def_attrs(self, fun=copy_func) self.default_install_path = 0 lst = self.to_list(self.source) self.meths.remove('process_source') for filename in lst: node = self.path.find_resource(filename) if not node: raise Errors.WafError('cannot find input file %s for processing' % filename) target = self.target if not target or len(lst) > 1: target = node.name # TODO the file path may be incorrect newnode = self.path.find_or_declare(target) tsk = self.create_task('copy', node, newnode) tsk.fun = self.fun tsk.chmod = getattr(self, 'chmod', Utils.O644) if not tsk.env: tsk.debug() raise Errors.WafError('task without an environment')
def apply_java(self): """ Create a javac task for compiling *.java files*. There can be only one javac task by task generator. """ Utils.def_attrs( self, jarname="", classpath="", sourcepath=".", srcdir=".", jar_mf_attributes={}, jar_mf_classpath=[], ) outdir = getattr(self, "outdir", None) if outdir: if not isinstance(outdir, Node.Node): outdir = self.path.get_bld().make_node(self.outdir) else: outdir = self.path.get_bld() outdir.mkdir() self.outdir = outdir self.env.OUTDIR = outdir.abspath() self.javac_task = tsk = self.create_task("javac") tmp = [] srcdir = getattr(self, "srcdir", "") if isinstance(srcdir, Node.Node): srcdir = [srcdir] for x in Utils.to_list(srcdir): if isinstance(x, Node.Node): y = x else: y = self.path.find_dir(x) if not y: self.bld.fatal( f"Could not find the folder {x} from {self.path}") tmp.append(y) tsk.srcdir = tmp if getattr(self, "compat", None): tsk.env.append_value("JAVACFLAGS", ["-source", str(self.compat)]) if hasattr(self, "sourcepath"): fold = [ isinstance(x, Node.Node) and x or self.path.find_dir(x) for x in self.to_list(self.sourcepath) ] names = os.pathsep.join([x.srcpath() for x in fold]) else: names = [x.srcpath() for x in tsk.srcdir] if names: tsk.env.append_value("JAVACFLAGS", ["-sourcepath", names])
def apply_java(self): Utils.def_attrs(self, jarname='', jaropts='', classpath='', sourcepath='.', srcdir='.', source_re='**/*.java', jar_mf_attributes={}, jar_mf_classpath=[]) nodes_lst = [] if not self.classpath: if not self.env['CLASSPATH']: self.env['CLASSPATH'] = '..' + os.pathsep + '.' else: self.env['CLASSPATH'] = self.classpath srcdir_node = self.path.find_dir(self.srcdir) if not srcdir_node: raise Errors.WafError('could not find srcdir %r' % self.srcdir) src_nodes = srcdir_node.ant_glob(self.source_re) bld_nodes = [x.change_ext('.class') for x in src_nodes] for x in src_nodes: x.sig = Utils.h_file(x.abspath()) self.env['OUTDIR'] = [srcdir_node.get_bld().abspath()] tsk = self.create_task('javac') tsk.set_inputs(src_nodes) tsk.set_outputs(bld_nodes) if getattr(self, 'compat', None): tsk.env.append_value('JAVACFLAGS', ['-source', self.compat]) if hasattr(self, 'sourcepath'): fold = [self.path.find_dir(x) for x in self.to_list(self.sourcepath)] names = os.pathsep.join([x.srcpath() for x in fold]) else: names = srcdir_node.srcpath() if names: tsk.env.append_value('JAVACFLAGS', ['-sourcepath', names]) if self.jarname: tsk = self.create_task('jar_create') tsk.set_outputs(self.path.find_or_declare(self.jarname)) if not self.env['JAROPTS']: if self.jaropts: self.env['JAROPTS'] = self.jaropts else: dirs = '.' self.env['JAROPTS'] = ['-C', ''.join(self.env['OUTDIR']), dirs]
def apply_java(self): """ Create a javac task for compiling *.java files*. There can be only one javac task by task generator. """ Utils.def_attrs( self, jarname="", classpath="", sourcepath=".", srcdir=".", jar_mf_attributes={}, jar_mf_classpath=[] ) nodes_lst = [] outdir = getattr(self, "outdir", None) if outdir: if not isinstance(outdir, Node.Node): outdir = self.path.get_bld().make_node(self.outdir) else: outdir = self.path.get_bld() outdir.mkdir() self.outdir = outdir self.env["OUTDIR"] = outdir.abspath() self.javac_task = tsk = self.create_task("javac") tmp = [] srcdir = getattr(self, "srcdir", "") if isinstance(srcdir, Node.Node): srcdir = [srcdir] for x in Utils.to_list(srcdir): if isinstance(x, Node.Node): y = x else: y = self.path.find_dir(x) if not y: self.bld.fatal("Could not find the folder %s from %s" % (x, self.path)) tmp.append(y) tsk.srcdir = tmp if getattr(self, "compat", None): tsk.env.append_value("JAVACFLAGS", ["-source", self.compat]) if hasattr(self, "sourcepath"): fold = [isinstance(x, Node.Node) and x or self.path.find_dir(x) for x in self.to_list(self.sourcepath)] names = os.pathsep.join([x.srcpath() for x in fold]) else: names = [x.srcpath() for x in tsk.srcdir] if names: tsk.env.append_value("JAVACFLAGS", ["-sourcepath", names])
def init_ml(self): Utils.def_attrs(self, type = 'all', incpaths_lst = [], bld_incpaths_lst = [], mlltasks = [], mlytasks = [], mlitasks = [], native_tasks = [], bytecode_tasks = [], linktasks = [], bytecode_env = None, native_env = None, compiled_tasks = [], includes = '', uselib = '', are_deps_set = 0)
def init_ml(self): Utils.def_attrs(self, type='all', incpaths_lst=[], bld_incpaths_lst=[], mlltasks=[], mlytasks=[], mlitasks=[], native_tasks=[], bytecode_tasks=[], linktasks=[], bytecode_env=None, native_env=None, compiled_tasks=[], includes='', uselib='', are_deps_set=0)
def init_cmd_output(self): Utils.def_attrs( self, stdin=None, stdout=None, stderr=None, # the command to execute command=None, # whether it is an external command; otherwise it is assumed # to be an executable binary or script that lives in the # source or build tree. command_is_external=False, # extra parameters (argv) to pass to the command (excluding # the command itself) argv=[], # dependencies to other objects -> this is probably not what you want (ita) # values must be 'task_gen' instances (not names!) dependencies=[], # dependencies on env variable contents dep_vars=[], # input files that are implicit, i.e. they are not # stdin, nor are they mentioned explicitly in argv hidden_inputs=[], # output files that are implicit, i.e. they are not # stdout, nor are they mentioned explicitly in argv hidden_outputs=[], # change the subprocess to this cwd (must use obj.input_dir() or output_dir() here) cwd=None, # OS environment variables to pass to the subprocess # if None, use the default environment variables unchanged os_env=None)
def apply_subst(self): Utils.def_attrs(self, fun=subst_func) lst = self.to_list(self.source) self.meths.remove('process_source') self.dict = getattr(self, 'dict', {}) for filename in lst: node = self.path.find_resource(filename) if not node: raise Errors.WafError('cannot find input file %s for processing' % filename) if self.target: newnode = self.path.find_or_declare(self.target) else: newnode = node.change_ext('') try: self.dict = self.dict.get_merged_dict() except AttributeError: pass if self.dict and not self.env['DICT_HASH']: self.env = self.env.derive() keys = list(self.dict.keys()) keys.sort() lst = [self.dict[x] for x in keys] self.env['DICT_HASH'] = str(Utils.h_list(lst)) tsk = self.create_task('copy', node, newnode) tsk.fun = self.fun tsk.dict = self.dict tsk.dep_vars = ['DICT_HASH'] tsk.chmod = getattr(self, 'chmod', Utils.O644) if not tsk.env: tsk.debug() raise Errors.WafError('task without an environment')
def init_cmd_output(self): Utils.def_attrs(self, stdin = None, stdout = None, stderr = None, command = None, command_is_external = False, argv = [], dependencies = [], dep_vars = [], hidden_inputs = [], hidden_outputs = [], cwd = None, os_env = None)
def apply_subst(self): Utils.def_attrs(self, fun=subst_func) lst = self.to_list(self.source) self.meths.remove("process_source") self.dict = getattr(self, "dict", {}) for filename in lst: node = self.path.find_resource(filename) if not node: raise Errors.WafError("cannot find input file %s for processing" % filename) if self.target: newnode = self.path.find_or_declare(self.target) else: newnode = node.change_ext("") try: self.dict = self.dict.get_merged_dict() except AttributeError: pass if self.dict and not self.env["DICT_HASH"]: self.env = self.env.derive() keys = list(self.dict.keys()) keys.sort() lst = [self.dict[x] for x in keys] self.env["DICT_HASH"] = str(Utils.h_list(lst)) tsk = self.create_task("copy", node, newnode) tsk.fun = self.fun tsk.dict = self.dict tsk.dep_vars = ["DICT_HASH"] tsk.chmod = getattr(self, "chmod", Utils.O644) if not tsk.env: tsk.debug() raise Errors.WafError("task without an environment")
def apply_java(self): Utils.def_attrs(self, jarname='', classpath='', sourcepath='.', srcdir='.', jar_mf_attributes={}, jar_mf_classpath=[]) nodes_lst = [] if not self.classpath: if not self.env['CLASSPATH']: self.env['CLASSPATH'] = '..' + os.pathsep + '.' else: self.env['CLASSPATH'] = self.classpath if isinstance(self.srcdir, self.path.__class__): srcdir_node = self.srcdir else: srcdir_node = self.path.find_dir(self.srcdir) if not srcdir_node: raise Errors.WafError('could not find srcdir %r' % self.srcdir) self.env['OUTDIR'] = [srcdir_node.get_src().srcpath()] self.javac_task = tsk = self.create_task('javac') tsk.srcdir = srcdir_node if getattr(self, 'compat', None): tsk.env.append_value('JAVACFLAGS', ['-source', self.compat]) if hasattr(self, 'sourcepath'): fold = [isinstance(x, self.path.__class__) and x or self.path.find_dir(x) for x in self.to_list(self.sourcepath)] names = os.pathsep.join([x.srcpath() for x in fold]) else: names = srcdir_node.srcpath() if names: tsk.env.append_value('JAVACFLAGS', ['-sourcepath', names]) """
def ping(self): Utils.def_attrs(self,srcglob='**') srcdir=getattr(self,'srcdir',None) if srcdir: if isinstance(srcdir,Node.Node): srcnode=srcdir else: srcnode=self.path.find_node(srcdir) else: self.bld.fatal("You must specifiy a source dir") if not srcnode: self.bld.fatal("Invalid source directory: %s" % srcdir) outdir=getattr(self,'outdir',None) if outdir: if not isinstance(outdir,Node.Node): outdir=self.path.get_bld().make_node(self.outdir) else: outdir=self.path.get_bld() for input in srcnode.ant_glob(self.srcglob): tsk = self.create_task('Copy') output=outdir.find_or_declare(input.path_from(srcnode)) tsk.set_inputs(input) tsk.set_outputs(output)
def apply_scalac(self): Utils.def_attrs( self, jarname="", classpath="", sourcepath=".", srcdir=".", jar_mf_attributes={}, jar_mf_classpath=[], ) outdir = getattr(self, "outdir", None) if outdir: if not isinstance(outdir, Node.Node): outdir = self.path.get_bld().make_node(self.outdir) else: outdir = self.path.get_bld() outdir.mkdir() self.env["OUTDIR"] = outdir.abspath() self.scalac_task = tsk = self.create_task("scalac") tmp = [] srcdir = getattr(self, "srcdir", "") if isinstance(srcdir, Node.Node): srcdir = [srcdir] for x in Utils.to_list(srcdir): if isinstance(x, Node.Node): y = x else: y = self.path.find_dir(x) if not y: self.bld.fatal(f"Could not find the folder {x} from {self.path}") tmp.append(y) tsk.srcdir = tmp
def halide(self): Utils.def_attrs(self, args=[], halide_env={}, ) bld = self.bld env = self.halide_env try: if isinstance(env, str): env = dict(x.split('=') for x in env.split()) elif isinstance(env, list): env = dict(x.split('=') for x in env) assert isinstance(env, dict) except Exception as e: if not isinstance(e, ValueError) \ and not isinstance(e, AssertionError): raise raise Errors.WafError( "halide_env must be under the form" \ " {'HL_x':'a', 'HL_y':'b'}" \ " or ['HL_x=y', 'HL_y=b']" \ " or 'HL_x=y HL_y=b'") src = self.to_nodes(self.source) assert len(src) == 1, "Only one source expected" src = src[0] args = Utils.to_list(self.args) def change_ext(src, ext): # Return a node with a new extension, in an appropriate folder name = src.name xpos = src.name.rfind('.') if xpos == -1: xpos = len(src.name) newname = name[:xpos] + ext if src.is_child_of(bld.bldnode): node = src.get_src().parent.find_or_declare(newname) else: node = bld.bldnode.find_or_declare(newname) return node def to_nodes(self, lst, path=None): tmp = [] path = path or self.path find = path.find_or_declare if isinstance(lst, self.path.__class__): lst = [lst] for x in Utils.to_list(lst): if isinstance(x, str): node = find(x) else: node = x tmp.append(node) return tmp tgt = to_nodes(self, self.target) if not tgt: tgt = [change_ext(src, '.o'), change_ext(src, '.h')] cwd = tgt[0].parent.abspath() task = self.create_task('run_halide_gen', src, tgt, cwd=cwd) task.env.append_unique('HALIDE_ARGS', args) if task.env.env == []: task.env.env = {} task.env.env.update(env) task.env.HALIDE_ENV = " ".join(("%s=%s" % (k,v)) for (k,v) in sorted(env.items())) task.env.HALIDE_ARGS = args try: self.compiled_tasks.append(task) except AttributeError: self.compiled_tasks = [task] self.source = []
def halide(self): Utils.def_attrs( self, args=[], halide_env={}, ) bld = self.bld env = self.halide_env try: if isinstance(env, str): env = dict(x.split("=") for x in env.split()) elif isinstance(env, list): env = dict(x.split("=") for x in env) assert isinstance(env, dict) except Exception as e: if not isinstance(e, ValueError) and not isinstance(e, AssertionError): raise raise Errors.WafError("halide_env must be under the form" " {'HL_x':'a', 'HL_y':'b'}" " or ['HL_x=y', 'HL_y=b']" " or 'HL_x=y HL_y=b'") src = self.to_nodes(self.source) assert len(src) == 1, "Only one source expected" src = src[0] args = Utils.to_list(self.args) def change_ext(src, ext): # Return a node with a new extension, in an appropriate folder name = src.name xpos = src.name.rfind(".") if xpos == -1: xpos = len(src.name) newname = name[:xpos] + ext if src.is_child_of(bld.bldnode): node = src.get_src().parent.find_or_declare(newname) else: node = bld.bldnode.find_or_declare(newname) return node def to_nodes(self, lst, path=None): tmp = [] path = path or self.path find = path.find_or_declare if isinstance(lst, self.path.__class__): lst = [lst] for x in Utils.to_list(lst): if isinstance(x, str): node = find(x) else: node = x tmp.append(node) return tmp tgt = to_nodes(self, self.target) if not tgt: tgt = [change_ext(src, ".o"), change_ext(src, ".h")] cwd = tgt[0].parent.abspath() task = self.create_task("run_halide_gen", src, tgt, cwd=cwd) task.env.append_unique("HALIDE_ARGS", args) if task.env.env == []: task.env.env = {} task.env.env.update(env) task.env.HALIDE_ENV = " ".join( (f"{k}={v}") for (k, v) in sorted(env.items())) task.env.HALIDE_ARGS = args try: self.compiled_tasks.append(task) except AttributeError: self.compiled_tasks = [task] self.source = []
def init_command(self): Utils.def_attrs(self, # other variables that can be used in the command: ${VARIABLE} variables = None, rule='')
def process_aar(self): ''' Find the Android library and unpack it so it's resources can be used by other modules ''' def _could_not_find_lib_error(): raise Errors.WafError('[ERROR] Could not find Android library %r' % self.name) bld = self.bld platform = bld.env['PLATFORM'] # the android studio project generation also requires this to run in order for the # aar dependencies to get added to gradle correctly if not (bld.is_android_platform(platform) or bld.cmd == 'android_studio'): Logs.debug('android_library: Skipping the reading of the aar') return Utils.def_attrs( self, manifest=None, package='', classpath=[], native_libs=[], aapt_assets=None, aapt_resources=None, ) group = self.group_id version = self.version search_paths = self.paths android_cache = bld.get_android_cache_node() aar_cache = android_cache.make_node('aar') aar_cache.mkdir() Logs.debug('android_library: Processing Android library %s', self.name) lib_node = None if search_paths: aar_filename = '{}.aar'.format(self.name) for path in search_paths: if not isinstance(path, Node.Node): path = bld.root.find_node(path) or self.path.find_node(path) if not path: Logs.debug( 'android_library: Unable to find node for path %s', path) continue Logs.debug('android_library: Searching path {}'.format( path.abspath())) lib_node = path.find_node(aar_filename) if lib_node: break else: _could_not_find_lib_error() self.android_studio_name = 'file:{}'.format( lib_node.abspath()).replace('\\', '/') else: file_url, aar_filename = search_maven_repos(bld, self.name, group, version) if not (file_url and aar_filename): _could_not_find_lib_error() if file_url.startswith('file:'): local_path = file_url[5:] lib_node = bld.root.find_node(local_path) if not lib_node: _could_not_find_lib_error() else: lib_node = aar_cache.find_node(aar_filename) if not lib_node: lib_node = aar_cache.make_node(aar_filename) Logs.debug('android_library: Downloading %s => %s', file_url, lib_node.abspath()) try: url_opener = urllib.FancyURLopener() url_opener.retrieve(file_url, filename=lib_node.abspath()) except: bld.Fatal( '[ERROR] Failed to download Android library {} from {}.' .format(self.name, file_url)) if not version: version = os.path.splitext(aar_filename)[0].split('-')[-1] self.android_studio_name = '{}:{}:{}'.format(group, self.name, version) lib_node.sig = Utils.h_file(lib_node.abspath()) folder_name = os.path.splitext(aar_filename)[0] extraction_node = aar_cache.make_node(folder_name) if os.path.exists(extraction_node.abspath()): extraction_node.delete() extraction_node.mkdir() aar_file = zipfile.ZipFile(file=lib_node.abspath()) aar_file.extractall(path=extraction_node.abspath()) Logs.debug('android_library: AAR contents = {}'.format( aar_file.namelist())) # required entries from the aar main_jar_file = extraction_node.find_node('classes.jar') if not main_jar_file: self.bld.fatal( '[ERROR] Unable to find the required classes.jar from {}'.format( lib_name)) self.manifest = extraction_node.find_node('AndroidManifest.xml') if not self.manifest: self.bld.fatal( '[ERROR] Unable to find the required AndroidManifest.xml from {}'. format(lib_name)) self.package = get_package_name(self.manifest.abspath()) if not self.package: self.bld.fatal( '[ERROR] Failed to extract the package name from AndroidManifest.xml in {}' .format(lib_name)) self.aapt_resources = extraction_node.find_dir('res') if not self.aapt_resources: self.bld.fatal( '[ERROR] Unable to find the required resources directory - res - from {}' .format(lib_name)) # optional entries from the aar self.aapt_assets = extraction_node.find_dir('assets') java_libs = extraction_node.find_dir('libs') if java_libs: self.classpath = java_libs.ant_glob('**/*.jar') native_lib_path = 'jni/{}'.format(self.bld.env['ANDROID_ARCH']) native_libs = extraction_node.find_dir(native_lib_path) if native_libs: self.native_libs_root = native_libs self.native_libs = native_libs.ant_glob('**/*.so') # create the fake tasks self.jar_task = self.create_task('fake_jar', [], main_jar_file) self.aar_task = self.create_task('fake_aar', [], lib_node) # task chaining self.aar_task.set_run_after(self.jar_task)
def process_aar(self): """ Find the Android library and unpack it so it's resources can be used by other modules """ if self.bld.env['PLATFORM'] not in ('android_armv7_clang', 'android_armv7_gcc', 'project_generator'): Logs.debug('android_library: Skipping the reading of the aar') return Utils.def_attrs( self, manifest = None, package = '', classpath = [], native_libs = [], aapt_assets = None, aapt_resources = None, ) lib_node = None search_paths = [] if self.is_android_support_lib: android_api_level = str(self.env['ANDROID_SDK_VERSION_NUMBER']) Logs.debug('android_library: Searching for support library - %s - built with API %s', self.name, android_api_level) for path in self.lib_paths: if os.path.exists(path): entries = os.listdir(path) Logs.debug('android_library: All API versions installed {}'.format(entries)) api_versions = sorted([ entry for entry in entries if entry.startswith(android_api_level) ]) Logs.debug('android_library: Found versions {}'.format(api_versions)) highest_useable_version = api_versions[-1] search_paths.append(os.path.join(path, highest_useable_version)) self.android_studio_name = 'com.android.support:{}:{}'.format(self.name, highest_useable_version) lib_name = '{}-{}.aar'.format(self.name, highest_useable_version) break else: raise Errors.WafError('Unable to detect a valid useable version for Android support library %r' % self.name) else: lib_name = '{}.aar'.format(self.name) search_paths = self.lib_paths + [ self.path ] for path in search_paths: Logs.debug('android_library: Searching path {}'.format(path)) if not isinstance(path, Node.Node): path = self.bld.root.find_node(path) or self.path.find_node(path) if not path: Logs.debug('android_library: Unable to find node for path') continue lib_node = path.find_node(lib_name) if lib_node: lib_node.sig = Utils.h_file(lib_node.abspath()) break else: raise Errors.WafError('Could not find Android library %r' % self.name) android_cache = self.bld.get_android_cache_node() extraction_node = android_cache.make_node([ 'aar', self.name ]) if os.path.exists(extraction_node.abspath()): extraction_node.delete() extraction_node.mkdir() aar_file = zipfile.ZipFile(file = lib_node.abspath()) aar_file.extractall(path = extraction_node.abspath()) Logs.debug('android_library: AAR contents = {}'.format(aar_file.namelist())) # required entries from the aar main_jar_file = extraction_node.find_node('classes.jar') if not main_jar_file: self.bld.fatal('[ERROR] Unable to find the required classes.jar from {}'.format(lib_name)) self.manifest = extraction_node.find_node('AndroidManifest.xml') if not self.manifest: self.bld.fatal('[ERROR] Unable to find the required AndroidManifest.xml from {}'.format(lib_name)) self.package = get_package_name(self.manifest.abspath()) if not self.package: self.bld.fatal('[ERROR] Failed to extract the package name from AndroidManifest.xml in {}'.format(lib_name)) self.aapt_resources = extraction_node.find_dir('res') if not self.aapt_resources: self.bld.fatal('[ERROR] Unable to find the required resources directory - res - from {}'.format(lib_name)) # optional entries from the aar self.aapt_assets = extraction_node.find_dir('assets') java_libs = extraction_node.find_dir('libs') if java_libs: self.classpath = java_libs.ant_glob('**/*.jar') native_lib_path = 'jni/{}'.format(self.bld.env['ANDROID_ARCH']) native_libs = extraction_node.find_dir(native_lib_path) if native_libs: self.native_libs_root = native_libs self.native_libs = native_libs.ant_glob('**/*.so') # create the fake tasks self.jar_task = self.create_task('fake_jar', [], main_jar_file) self.aar_task = self.create_task('fake_aar', [], lib_node) # task chaining self.aar_task.set_run_after(self.jar_task)
def init_command(self): Utils.def_attrs(self, # other variables that can be used in the command: ${VARIABLE} variables = None, rule='')