chen3feng / blade-build / 566

pending completion

Build # 566

Build Type

Pull #616

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/chen3feng/blade-build/commit/<a class=hub.com/chen3feng/blade-build/commit/ad33223bc7736efec6551e4c7ff63f46aff87224">ad33223bc<a href="https://github.com/chen3feng/blade-build/commit/ad33223bc7736efec6551e4c7ff63f46aff87224">">Merge </a><a class="double-link" href="https://github.com/chen3feng/blade-build/commit/<a class="double-link" href="https://github.com/chen3feng/blade-build/commit/0beea6a2edc79f6a828b1c96eac219604477ad6f">0beea6a2e</a>">0beea6a2e</a><a href="https://github.com/chen3feng/blade-build/commit/ad33223bc7736efec6551e4c7ff63f46aff87224"> into 217c2ab81">217c2ab81</a>

Pull Request Pull Request #616: Remove scons related code

Run Details

44 of 44 new or added lines in 12 files covered. (100.0%)

2617 of 6787 relevant lines covered (38.56%)

0.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.88

/src/blade/target.py

# Copyright (c) 2011 Tencent Inc.
# All rights reserved.
#
# Author: Michaelpeng <michaelpeng@tencent.com>
# Date:   October 20, 2011


"""
 This is the target module which is the super class of all of the targets.
"""

from __future__ import absolute_import

import os
import string

from blade import config
from blade import console
from blade.blade_util import var_to_list, iteritems


def _normalize_one(target, working_dir):
    """Normalize target from command line form into canonical form.

    Target canonical form: dir:name
        dir: relative to blade_root_dir, use '.' for blade_root_dir
        name: name  if target is dir:name
              '*'   if target is dir
              '...' if target is dir/...
    """
    if target.startswith('//'):
        target = target[2:]
    elif target.startswith('/'):
        console.error_exit('Invalid target "%s" starting from root path.' % target)
    else:
        if working_dir != '.':
            target = os.path.join(working_dir, target)

    if ':' in target:
        path, name = target.rsplit(':', 1)
    else:
        if target.endswith('...'):
            path = target[:-3]
            name = '...'
        else:
            path = target
            name = '*'
    path = os.path.normpath(path)
    return '%s:%s' % (path, name)


def normalize(targets, working_dir):
    """Normalize target list from command line form into canonical form."""
    return [_normalize_one(target, working_dir) for target in targets]


class Target(object):
    """Abstract target class.

    This class should be derived by subclass like CcLibrary CcBinary
    targets, etc.

    """

    def __init__(self,
                 name,
                 target_type,
                 srcs,
                 deps,
                 visibility,
                 blade,
                 kwargs):
        """Init method.

        Init the target.

        """
        self.blade = blade
        self.build_path = self.blade.get_build_path()
        current_source_path = self.blade.get_current_source_path()
        self.target_database = self.blade.get_target_database()

        self.key = (current_source_path, name)
        self.fullname = '%s:%s' % self.key
        self.name = name
        self.path = current_source_path
        self.type = target_type
        self.srcs = srcs
        self.deps = []
        self.expanded_deps = []
        self.visibility = 'PUBLIC'
        self.data = {}
        self.data['test_timeout'] = config.get_item('global_config', 'test_timeout')

        # Keep track of target filess generated by this target. Note that one target rule
        # may correspond to several target files, such as:
        # proto_library: static lib/shared lib/jar variables
        self.data['targets'] = {}
        self.data['default_target'] = ''

        self._check_name()
        self._check_kwargs(kwargs)
        self._check_srcs()
        self._check_deps(deps)
        self._init_target_deps(deps)
        self._init_visibility(visibility)
        self.build_rules = []
        self.data['generated_hdrs'] = []

    def dump(self):
        """Dump to a dict"""
        target = {
            'type': self.type,
            'path': self.path,
            'name': self.name,
            'srcs': self.srcs,
            'deps': self.deps,
            'visibility': self.visibility,
        }
        target.update(self.data)
        return target

    def debug(self, msg):
        """Print message with target full name prefix"""
        console.debug('//%s: %s' % (self.fullname, msg))

    def info(self, msg):
        """Print message with target full name prefix"""
        console.info('//%s: %s' % (self.fullname, msg))

    def warning(self, msg):
        """Print message with target full name prefix"""
        console.warning('//%s: %s' % (self.fullname, msg))

    def error(self, msg):
        """Print message with target full name prefix"""
        console.error('//%s: %s' % (self.fullname, msg))

    def error_exit(self, msg, code=1):
        """Print message with target full name prefix and exit"""
        console.error_exit('//%s: %s' % (self.fullname, msg), code=code)

    def _prepare_to_generate_rule(self):
        """Should be overridden. """
        console.error_exit('_prepare_to_generate_rule should be overridden in subclasses')

    def _check_name(self):
        if '/' in self.name:
            self.error_exit('Invalid target name, should not contain dir part')

    def _check_kwargs(self, kwargs):
        if kwargs:
            self.error_exit('unrecognized options %s' % kwargs)

    def _allow_duplicate_source(self):
        """Whether the target allows duplicate source file with other targets"""
        return False

    # Keep the relationship of all src -> target.
    # Used by build rules to ensure that a source file occurs in
    # exactly one target(only library target).
    __src_target_map = {}

    def _check_srcs(self):
        """Check source files.

        """
        dups = []
        srcset = set()
        for s in self.srcs:
            if s in srcset:
                dups.append(s)
            else:
                srcset.add(s)
        if dups:
            self.error_exit('Duplicate source file paths: %s ' % dups)

        # Check if one file belongs to two different targets.
        action = config.get_item('global_config', 'duplicated_source_action')
        for s in self.srcs:
            if '..' in s or s.startswith('/'):
                self.error_exit('Invalid source file path: %s. can only be relative path, and must '
                                'in current directory or subdirectories.' % s)

            src = os.path.normpath(os.path.join(self.path, s))
            target = self.fullname, self._allow_duplicate_source()
            if src not in Target.__src_target_map:
                Target.__src_target_map[src] = target
            else:
                target_existed = Target.__src_target_map[src]
                if target_existed != target:
                    # Always preserve the target which disallows
                    # duplicate source files in the map
                    if target_existed[1]:
                        Target.__src_target_map[src] = target
                    elif target[1]:
                        pass
                    else:
                        message = 'Source file %s belongs to {%s, %s}' % (
                            s, target_existed[0], target[0])
                        if action == 'error':
                            console.error_exit(message)
                        elif action == 'warning':
                            console.warning(message)

    def _add_hardcode_library(self, hardcode_dep_list):
        """Add hardcode dep list to key's deps. """
        for dep in hardcode_dep_list:
            dkey = self._convert_string_to_target_helper(dep)
            if dkey[0] == '#':
                self._add_system_library(dkey, dep)
            if dkey not in self.expanded_deps:
                self.expanded_deps.append(dkey)

    def _add_system_library(self, key, name):
        """Add system library entry to database. """
        if key not in self.target_database:
            lib = SystemLibrary(name, self.blade)
            self.blade.register_target(lib)

    def _add_location_reference_target(self, m):
        """

        Parameters
        -----------
        m: A match object capturing the key and type of the referred target

        Returns
        -----------
        (key, type): the key and type of the referred target

        Description
        -----------
        Location reference makes it possible to refer to the build output of
        another target in the code base.

        General form:
            $(location //path/to:target)

        Some target types may produce more than one output according to the
        build options. Then each output can be referenced by an additional
        type tag:
            $(location //path:name)         # default target output
            $(location //path:name jar)     # jar output
            $(location //path:name so)      # so output

        Note that this method accepts a match object instead of a simple str.
        You could match/search/sub location references in a string with functions
        or RegexObject in re module. For example:

            m = {location regular expression}.search(s)
            if m:
                key, type = self._add_location_reference_target(m)
            else:
                # Not a location reference

        """
        if m:
            key, type = m.groups()
            if not type:
                type = ''
            type = type.strip()
            key = self._unify_dep(key)
            if key not in self.expanded_deps:
                self.expanded_deps.append(key)
            if key not in self.deps:
                self.deps.append(key)
            return key, type

    def _unify_dep(self, dep):
        """Unify dep to key"""
        if dep[0] == ':':
            # Depend on library in current directory
            dkey = (os.path.normpath(self.path), dep[1:])
        elif dep.startswith('//'):
            # Depend on library in remote directory
            if not ':' in dep:
                raise Exception('Wrong format in %s' % self.fullname)
            (path, lib) = dep[2:].rsplit(':', 1)
            dkey = (os.path.normpath(path), lib)
        elif dep.startswith('#'):
            # System libaray, they don't have entry in BUILD so we need
            # to add deps manually.
            dkey = ('#', dep[1:])
            self._add_system_library(dkey, dep)
        else:
            # Depend on library in relative subdirectory
            if not ':' in dep:
                raise Exception('Wrong format in %s' % self.fullname)
            (path, lib) = dep.rsplit(':', 1)
            if '..' in path:
                raise Exception("Don't use '..' in path")
            dkey = (os.path.normpath('%s/%s' % (
                self.path, path)), lib)

        return dkey

    def _init_target_deps(self, deps):
        """Init the target deps.

        Parameters
        -----------
        deps: the deps list in BUILD file.

        Description
        -----------
        Add target into target database and init the deps list.

        """
        for d in deps:
            dkey = self._unify_dep(d)
            if dkey not in self.expanded_deps:
                self.expanded_deps.append(dkey)
            if dkey not in self.deps:
                self.deps.append(dkey)

    def _check_format(self, t):
        """

        Parameters
        -----------
        t: could be a dep or visibility specified in BUILD file

        Description
        -----------
        Do some basic format check.

        """
        if not (t.startswith(':') or t.startswith('#') or
                t.startswith('//') or t.startswith('./')):
            self.error_exit('Invalid format %s.' % t)
        if t.count(':') > 1:
            self.error_exit("Invalid format %s, missing ',' between labels?" % t)

    def _check_deps(self, deps):
        """_check_deps

        Parameters
        -----------
        deps: the deps list in BUILD file

        Description
        -----------
        Check whether deps are in valid format.

        """
        for dep in deps:
            self._check_format(dep)

    def _init_visibility(self, visibility):
        """

        Parameters
        -----------
        visibility: the visibility list in BUILD file

        Description
        -----------
        Visibility determines whether another target is able to depend
        on this target.

        Visibility specify a list of targets in the same form as deps,
        i.e. //path/to:target. The default value of visibility is PUBLIC,
        which means this target is visible globally within the code base.
        Note that targets inside the same BUILD file are always visible
        to each other.

        """
        if visibility is None:
            return

        visibility = var_to_list(visibility)
        if visibility == ['PUBLIC']:
            return

        self.visibility = []
        for v in visibility:
            self._check_format(v)
            key = self._unify_dep(v)
            if key not in self.visibility:
                self.visibility.append(key)

    def _check_deprecated_deps(self):
        """check that whether it depends upon deprecated target.
        It should be overridden in subclass.
        """
        pass

    def _expand_deps_generation(self):
        """Expand the generation process and generated rules of dependencies.

        Such as, given a proto_library target, it should generate Java rules
        in addition to C++ rules once it's depended by a java_library target.
        """
        pass

    def _get_java_pack_deps(self):
        """
        Return java package dependencies excluding provided dependencies

        target jars represent a path to jar archive. Each jar is built by
        java_library(prebuilt)/scala_library/proto_library.

        maven jars represent maven artifacts within local repository built
        by maven_jar(...).

        Returns:
            A tuple of (target jars, maven jars)
        """
        return [], []

    def _source_file_path(self, name):
        """_source_file_path.

        Parameters
        -----------
        name: the source's name

        Returns
        -----------
        The source's full path in full blade dir tree

        """
        return os.path.normpath(os.path.join(self.path, name))

    def _target_file_path(self, name=''):
        """_target_file_path.

        Parameters
        -----------
        name: the target's name

        Returns
        -----------
        The target's path below building path

        Description
        -----------
        Concatenating building path, target path and target name to be full
        file path.

        """
        if not name:
            name = self.name
        return os.path.join(self.build_path, self.path, name)

    def _add_target_file(self, label, path):
        """

        Parameters
        -----------
        label: label of the target file as key in the dictionary
        path: the path of target file as value in the dictionary

        Description
        -----------
        Keep track of the output files built by the target itself.
        Set the default target if needed.

        """
        self.data['targets'][label] = path
        if not self.data['default_target']:
            self.data['default_target'] = path

    def _add_default_target_file(self, label, path):
        """

        Parameters
        -----------
        label: label of the target file as key in the dictionary
        path: the path of target file as value in the dictionary

        Description
        -----------
        Keep track of the default target file which could be referenced
        later without specifying label

        """
        self.data['default_target'] = path
        self._add_target_file(label, path)

    def _get_target_file(self, label=''):
        """

        Parameters
        -----------
        label: label of the file built by the target

        Returns
        -----------
        The target file path or list of file paths

        Description
        -----------
        Return the target file path corresponding to the specified label,
        return empty if label doesn't exist in the dictionary

        """
        if label:
            return self.data['targets'].get(label, '')
        return self.data['default_target']

    def _get_target_files(self):
        """

        Returns
        -----------
        All the target files built by the target itself

        """
        results = set()
        for _, v in iteritems(self.data['targets']):
            if isinstance(v, list):
                results.update(v)
            else:
                results.add(v)
        return sorted(results)

    def _write_rule(self, rule):
        """_write_rule.
        Append the rule to the buffer at first.
        Args:
            rule: the rule generated by certain target
        """
        self.build_rules.append('%s\n' % rule)

    def ninja_rules(self):
        """Generate ninja rules for specific target. """
        raise NotImplementedError(self.fullname)

    def ninja_build(self, rule, outputs, inputs=None,
                    implicit_deps=None, order_only_deps=None,
                    variables=None, implicit_outputs=None):
        """Generate a ninja build statement with specified parameters. """
        outs = var_to_list(outputs)
        if implicit_outputs:
            outs.append('|')
            outs += var_to_list(implicit_outputs)
        ins = var_to_list(inputs) if inputs else []
        if implicit_deps:
            ins.append('|')
            ins += var_to_list(implicit_deps)
        if order_only_deps:
            ins.append('||')
            ins += var_to_list(order_only_deps)
        self._write_rule('build %s: %s %s' % (' '.join(outs), rule, ' '.join(ins)))

        if variables:
            assert isinstance(variables, dict)
            for name, v in iteritems(variables):
                if v:
                    self._write_rule('  %s = %s' % (name, v))
                else:
                    self._write_rule('  %s =' % name)

    def get_rules(self):
        """Return build rules. """
        return self.build_rules

    def _convert_string_to_target_helper(self, target_string):
        """
        Converting a string like thirdparty/gtest:gtest to tuple
        (target_path, target_name)
        """
        if target_string:
            if target_string.startswith('#'):
                return ('#', target_string[1:])
            elif target_string.find(':') != -1:
                path, name = target_string.split(':')
                path = path.strip()
                if path.startswith('//'):
                    path = path[2:]
                return (path, name.strip())

        console.error_exit('invalid target lib format: %s, '
                           'should be #lib_name or lib_path:lib_name' %
                           target_string)


class SystemLibrary(Target):
    def __init__(self, name, blade):
        name = name[1:]
        Target.__init__(self, name, 'system_library', [], [], None, blade, {})
        self.key = ('#', name)
        self.fullname = '%s:%s' % self.key
        self.path = '#'

1	# Copyright (c) 2011 Tencent Inc.
2	# All rights reserved.
3	#
4	# Author: Michaelpeng <michaelpeng@tencent.com>
5	# Date: October 20, 2011
6
7
8	"""	1✔
9	This is the target module which is the super class of all of the targets.
10	"""
11
12	from __future__ import absolute_import	1✔
13
14	import os	1✔
15	import string	1✔
16
17	from blade import config	1✔
18	from blade import console	1✔
19	from blade.blade_util import var_to_list, iteritems	1✔
20
21
22	def _normalize_one(target, working_dir):	1✔
23	"""Normalize target from command line form into canonical form.
24
25	Target canonical form: dir:name
26	dir: relative to blade_root_dir, use '.' for blade_root_dir
27	name: name if target is dir:name
28	'*' if target is dir
29	'...' if target is dir/...
30	"""
31	if target.startswith('//'):	1✔
32	target = target[2:]	×
33	elif target.startswith('/'):	1✔
34	console.error_exit('Invalid target "%s" starting from root path.' % target)	×
35	else:
36	if working_dir != '.':	1✔
37	target = os.path.join(working_dir, target)	×
38
39	if ':' in target:	1✔
40	path, name = target.rsplit(':', 1)	1✔
41	else:
42	if target.endswith('...'):	×
43	path = target[:-3]	×
44	name = '...'	×
45	else:
46	path = target	×
47	name = '*'	×
48	path = os.path.normpath(path)	1✔
49	return '%s:%s' % (path, name)	1✔
50
51
52	def normalize(targets, working_dir):	1✔
53	"""Normalize target list from command line form into canonical form."""
54	return [_normalize_one(target, working_dir) for target in targets]	1✔
55
56
57	class Target(object):	1✔
58	"""Abstract target class.
59
60	This class should be derived by subclass like CcLibrary CcBinary
61	targets, etc.
62
63	"""
64
65	def __init__(self,	1✔
66	name,
67	target_type,
68	srcs,
69	deps,
70	visibility,
71	blade,
72	kwargs):
73	"""Init method.
74
75	Init the target.
76
77	"""
78	self.blade = blade	1✔
79	self.build_path = self.blade.get_build_path()	1✔
80	current_source_path = self.blade.get_current_source_path()	1✔
81	self.target_database = self.blade.get_target_database()	1✔
82
83	self.key = (current_source_path, name)	1✔
84	self.fullname = '%s:%s' % self.key	1✔
85	self.name = name	1✔
86	self.path = current_source_path	1✔
87	self.type = target_type	1✔
88	self.srcs = srcs	1✔
89	self.deps = []	1✔
90	self.expanded_deps = []	1✔
91	self.visibility = 'PUBLIC'	1✔
92	self.data = {}	1✔
93	self.data['test_timeout'] = config.get_item('global_config', 'test_timeout')	1✔
94
95	# Keep track of target filess generated by this target. Note that one target rule
96	# may correspond to several target files, such as:
97	# proto_library: static lib/shared lib/jar variables
98	self.data['targets'] = {}	1✔
99	self.data['default_target'] = ''	1✔
100
101	self._check_name()	1✔
102	self._check_kwargs(kwargs)	1✔
103	self._check_srcs()	1✔
104	self._check_deps(deps)	1✔
105	self._init_target_deps(deps)	1✔
106	self._init_visibility(visibility)	1✔
107	self.build_rules = []	1✔
108	self.data['generated_hdrs'] = []	1✔
109
110	def dump(self):	1✔
111	"""Dump to a dict"""
112	target = {	×
113	'type': self.type,
114	'path': self.path,
115	'name': self.name,
116	'srcs': self.srcs,
117	'deps': self.deps,
118	'visibility': self.visibility,
119	}
120	target.update(self.data)	×
121	return target	×
122
123	def debug(self, msg):	1✔
124	"""Print message with target full name prefix"""
125	console.debug('//%s: %s' % (self.fullname, msg))	×
126
127	def info(self, msg):	1✔
128	"""Print message with target full name prefix"""
129	console.info('//%s: %s' % (self.fullname, msg))	×
130
131	def warning(self, msg):	1✔
132	"""Print message with target full name prefix"""
133	console.warning('//%s: %s' % (self.fullname, msg))	×
134
135	def error(self, msg):	1✔
136	"""Print message with target full name prefix"""
137	console.error('//%s: %s' % (self.fullname, msg))	×
138
139	def error_exit(self, msg, code=1):	1✔
140	"""Print message with target full name prefix and exit"""
141	console.error_exit('//%s: %s' % (self.fullname, msg), code=code)	×
142
143	def _prepare_to_generate_rule(self):	1✔
144	"""Should be overridden. """
145	console.error_exit('_prepare_to_generate_rule should be overridden in subclasses')	×
146
147	def _check_name(self):	1✔
148	if '/' in self.name:	1✔
149	self.error_exit('Invalid target name, should not contain dir part')	×
150
151	def _check_kwargs(self, kwargs):	1✔
152	if kwargs:	1✔
153	self.error_exit('unrecognized options %s' % kwargs)	×
154
155	def _allow_duplicate_source(self):	1✔
156	"""Whether the target allows duplicate source file with other targets"""
157	return False	1✔
158
159	# Keep the relationship of all src -> target.
160	# Used by build rules to ensure that a source file occurs in
161	# exactly one target(only library target).
162	__src_target_map = {}	1✔
163
164	def _check_srcs(self):	1✔
165	"""Check source files.
166
167	"""
168	dups = []	1✔
169	srcset = set()	1✔
170	for s in self.srcs:	1✔
171	if s in srcset:	1✔
172	dups.append(s)	×
173	else:
174	srcset.add(s)	1✔
175	if dups:	1✔
176	self.error_exit('Duplicate source file paths: %s ' % dups)	×
177
178	# Check if one file belongs to two different targets.
179	action = config.get_item('global_config', 'duplicated_source_action')	1✔
180	for s in self.srcs:	1✔
181	if '..' in s or s.startswith('/'):	1✔
182	self.error_exit('Invalid source file path: %s. can only be relative path, and must '	×
183	'in current directory or subdirectories.' % s)
184
185	src = os.path.normpath(os.path.join(self.path, s))	1✔
186	target = self.fullname, self._allow_duplicate_source()	1✔
187	if src not in Target.__src_target_map:	1✔
188	Target.__src_target_map[src] = target	1✔
189	else:
190	target_existed = Target.__src_target_map[src]	×
191	if target_existed != target:	×
192	# Always preserve the target which disallows
193	# duplicate source files in the map
194	if target_existed[1]:	×
195	Target.__src_target_map[src] = target	×
196	elif target[1]:	×
197	pass	×
198	else:
199	message = 'Source file %s belongs to {%s, %s}' % (	×
200	s, target_existed[0], target[0])
201	if action == 'error':	×
202	console.error_exit(message)	×
203	elif action == 'warning':	×
204	console.warning(message)	×
205
206	def _add_hardcode_library(self, hardcode_dep_list):	1✔
207	"""Add hardcode dep list to key's deps. """
208	for dep in hardcode_dep_list:	×
209	dkey = self._convert_string_to_target_helper(dep)	×
210	if dkey[0] == '#':	×
211	self._add_system_library(dkey, dep)	×
212	if dkey not in self.expanded_deps:	×
213	self.expanded_deps.append(dkey)	×
214
215	def _add_system_library(self, key, name):	1✔
216	"""Add system library entry to database. """
217	if key not in self.target_database:	×
218	lib = SystemLibrary(name, self.blade)	×
219	self.blade.register_target(lib)	×
220
221	def _add_location_reference_target(self, m):	1✔
222	"""
223
224	Parameters
225	-----------
226	m: A match object capturing the key and type of the referred target
227
228	Returns
229	-----------
230	(key, type): the key and type of the referred target
231
232	Description
233	-----------
234	Location reference makes it possible to refer to the build output of
235	another target in the code base.
236
237	General form:
238	$(location //path/to:target)
239
240	Some target types may produce more than one output according to the
241	build options. Then each output can be referenced by an additional
242	type tag:
243	$(location //path:name) # default target output
244	$(location //path:name jar) # jar output
245	$(location //path:name so) # so output
246
247	Note that this method accepts a match object instead of a simple str.
248	You could match/search/sub location references in a string with functions
249	or RegexObject in re module. For example:
250
251	m = {location regular expression}.search(s)
252	if m:
253	key, type = self._add_location_reference_target(m)
254	else:
255	# Not a location reference
256
257	"""
258	if m:	×
259	key, type = m.groups()	×
260	if not type:	×
261	type = ''	×
262	type = type.strip()	×
263	key = self._unify_dep(key)	×
264	if key not in self.expanded_deps:	×
265	self.expanded_deps.append(key)	×
266	if key not in self.deps:	×
267	self.deps.append(key)	×
268	return key, type	×
269
270	def _unify_dep(self, dep):	1✔
271	"""Unify dep to key"""
272	if dep[0] == ':':	1✔
273	# Depend on library in current directory
274	dkey = (os.path.normpath(self.path), dep[1:])	1✔
275	elif dep.startswith('//'):	×
276	# Depend on library in remote directory
277	if not ':' in dep:	×
278	raise Exception('Wrong format in %s' % self.fullname)	×
279	(path, lib) = dep[2:].rsplit(':', 1)	×
280	dkey = (os.path.normpath(path), lib)	×
281	elif dep.startswith('#'):	×
282	# System libaray, they don't have entry in BUILD so we need
283	# to add deps manually.
284	dkey = ('#', dep[1:])	×
285	self._add_system_library(dkey, dep)	×
286	else:
287	# Depend on library in relative subdirectory
288	if not ':' in dep:	×
289	raise Exception('Wrong format in %s' % self.fullname)	×
290	(path, lib) = dep.rsplit(':', 1)	×
291	if '..' in path:	×
292	raise Exception("Don't use '..' in path")	×
293	dkey = (os.path.normpath('%s/%s' % (	×
294	self.path, path)), lib)
295
296	return dkey	1✔
297
298	def _init_target_deps(self, deps):	1✔
299	"""Init the target deps.
300
301	Parameters
302	-----------
303	deps: the deps list in BUILD file.
304
305	Description
306	-----------
307	Add target into target database and init the deps list.
308
309	"""
310	for d in deps:	1✔
311	dkey = self._unify_dep(d)	1✔
312	if dkey not in self.expanded_deps:	1✔
313	self.expanded_deps.append(dkey)	1✔
314	if dkey not in self.deps:	1✔
315	self.deps.append(dkey)	1✔
316
317	def _check_format(self, t):	1✔
318	"""
319
320	Parameters
321	-----------
322	t: could be a dep or visibility specified in BUILD file
323
324	Description
325	-----------
326	Do some basic format check.
327
328	"""
329	if not (t.startswith(':') or t.startswith('#') or	1✔
330	t.startswith('//') or t.startswith('./')):
331	self.error_exit('Invalid format %s.' % t)	×
332	if t.count(':') > 1:	1✔
333	self.error_exit("Invalid format %s, missing ',' between labels?" % t)	×
334
335	def _check_deps(self, deps):	1✔
336	"""_check_deps
337
338	Parameters
339	-----------
340	deps: the deps list in BUILD file
341
342	Description
343	-----------
344	Check whether deps are in valid format.
345
346	"""
347	for dep in deps:	1✔
348	self._check_format(dep)	1✔
349
350	def _init_visibility(self, visibility):	1✔
351	"""
352
353	Parameters
354	-----------
355	visibility: the visibility list in BUILD file
356
357	Description
358	-----------
359	Visibility determines whether another target is able to depend
360	on this target.
361
362	Visibility specify a list of targets in the same form as deps,
363	i.e. //path/to:target. The default value of visibility is PUBLIC,
364	which means this target is visible globally within the code base.
365	Note that targets inside the same BUILD file are always visible
366	to each other.
367
368	"""
369	if visibility is None:	1✔
370	return	1✔
371
372	visibility = var_to_list(visibility)	×
373	if visibility == ['PUBLIC']:	×
374	return	×
375
376	self.visibility = []	×
377	for v in visibility:	×
378	self._check_format(v)	×
379	key = self._unify_dep(v)	×
380	if key not in self.visibility:	×
381	self.visibility.append(key)	×
382
383	def _check_deprecated_deps(self):	1✔
384	"""check that whether it depends upon deprecated target.
385	It should be overridden in subclass.
386	"""
387	pass	×
388
389	def _expand_deps_generation(self):	1✔
390	"""Expand the generation process and generated rules of dependencies.
391
392	Such as, given a proto_library target, it should generate Java rules
393	in addition to C++ rules once it's depended by a java_library target.
394	"""
395	pass	1✔
396
397	def _get_java_pack_deps(self):	1✔
398	"""
399	Return java package dependencies excluding provided dependencies
400
401	target jars represent a path to jar archive. Each jar is built by
402	java_library(prebuilt)/scala_library/proto_library.
403
404	maven jars represent maven artifacts within local repository built
405	by maven_jar(...).
406
407	Returns:
408	A tuple of (target jars, maven jars)
409	"""
410	return [], []	×
411
412	def _source_file_path(self, name):	1✔
413	"""_source_file_path.
414
415	Parameters
416	-----------
417	name: the source's name
418
419	Returns
420	-----------
421	The source's full path in full blade dir tree
422
423	"""
424	return os.path.normpath(os.path.join(self.path, name))	1✔
425
426	def _target_file_path(self, name=''):	1✔
427	"""_target_file_path.
428
429	Parameters
430	-----------
431	name: the target's name
432
433	Returns
434	-----------
435	The target's path below building path
436
437	Description
438	-----------
439	Concatenating building path, target path and target name to be full
440	file path.
441
442	"""
443	if not name:	1✔
444	name = self.name	1✔
445	return os.path.join(self.build_path, self.path, name)	1✔
446
447	def _add_target_file(self, label, path):	1✔
448	"""
449
450	Parameters
451	-----------
452	label: label of the target file as key in the dictionary
453	path: the path of target file as value in the dictionary
454
455	Description
456	-----------
457	Keep track of the output files built by the target itself.
458	Set the default target if needed.
459
460	"""
461	self.data['targets'][label] = path	1✔
462	if not self.data['default_target']:	1✔
463	self.data['default_target'] = path	×
464
465	def _add_default_target_file(self, label, path):	1✔
466	"""
467
468	Parameters
469	-----------
470	label: label of the target file as key in the dictionary
471	path: the path of target file as value in the dictionary
472
473	Description
474	-----------
475	Keep track of the default target file which could be referenced
476	later without specifying label
477
478	"""
479	self.data['default_target'] = path	1✔
480	self._add_target_file(label, path)	1✔
481
482	def _get_target_file(self, label=''):	1✔
483	"""
484
485	Parameters
486	-----------
487	label: label of the file built by the target
488
489	Returns
490	-----------
491	The target file path or list of file paths
492
493	Description
494	-----------
495	Return the target file path corresponding to the specified label,
496	return empty if label doesn't exist in the dictionary
497
498	"""
499	if label:	1✔
500	return self.data['targets'].get(label, '')	1✔
501	return self.data['default_target']	×
502
503	def _get_target_files(self):	1✔
504	"""
505
506	Returns
507	-----------
508	All the target files built by the target itself
509
510	"""
511	results = set()	×
512	for _, v in iteritems(self.data['targets']):	×
513	if isinstance(v, list):	×
514	results.update(v)	×
515	else:
516	results.add(v)	×
517	return sorted(results)	×
518
519	def _write_rule(self, rule):	1✔
520	"""_write_rule.
521	Append the rule to the buffer at first.
522	Args:
523	rule: the rule generated by certain target
524	"""
525	self.build_rules.append('%s\n' % rule)	1✔
526
527	def ninja_rules(self):	1✔
528	"""Generate ninja rules for specific target. """
529	raise NotImplementedError(self.fullname)	×
530
531	def ninja_build(self, rule, outputs, inputs=None,	1✔
532	implicit_deps=None, order_only_deps=None,
533	variables=None, implicit_outputs=None):
534	"""Generate a ninja build statement with specified parameters. """
535	outs = var_to_list(outputs)	1✔
536	if implicit_outputs:	1✔
537	outs.append('\|')	×
538	outs += var_to_list(implicit_outputs)	×
539	ins = var_to_list(inputs) if inputs else []	1✔
540	if implicit_deps:	1✔
541	ins.append('\|')	×
542	ins += var_to_list(implicit_deps)	×
543	if order_only_deps:	1✔
544	ins.append('\|\|')	×
545	ins += var_to_list(order_only_deps)	×
546	self._write_rule('build %s: %s %s' % (' '.join(outs), rule, ' '.join(ins)))	1✔
547
548	if variables:	1✔
549	assert isinstance(variables, dict)	1✔
550	for name, v in iteritems(variables):	1✔
551	if v:	1✔
552	self._write_rule(' %s = %s' % (name, v))	1✔
553	else:
554	self._write_rule(' %s =' % name)	×
555
556	def get_rules(self):	1✔
557	"""Return build rules. """
558	return self.build_rules	1✔
559
560	def _convert_string_to_target_helper(self, target_string):	1✔
561	"""
562	Converting a string like thirdparty/gtest:gtest to tuple
563	(target_path, target_name)
564	"""
565	if target_string:	×
566	if target_string.startswith('#'):	×
567	return ('#', target_string[1:])	×
568	elif target_string.find(':') != -1:	×
569	path, name = target_string.split(':')	×
570	path = path.strip()	×
571	if path.startswith('//'):	×
572	path = path[2:]	×
573	return (path, name.strip())	×
574
575	console.error_exit('invalid target lib format: %s, '	×
576	'should be #lib_name or lib_path:lib_name' %
577	target_string)
578
579
580	class SystemLibrary(Target):	1✔
581	def __init__(self, name, blade):	1✔
582	name = name[1:]	×
583	Target.__init__(self, name, 'system_library', [], [], None, blade, {})	×
584	self.key = ('#', name)	×
585	self.fullname = '%s:%s' % self.key	×
586	self.path = '#'	×

chen3feng / blade-build / 566

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous