chen3feng / blade-build / 572

pending completion

Build # 572

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/<a class="double-link" href="https://git"><a class=hub.com/chen3feng/blade-build/commit/<a class="double-link" href="https://git"><a class=hub.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00ccf8868ca">eba716809<a href="https://github.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00ccf8868ca">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/chen3feng/blade-build/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00ccf8868ca&quot;&gt;eba716809&lt;/a&gt;&lt;a href=&quot;https://github.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00ccf8868ca&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00c&lt;/a&gt;cf8868ca&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/<a class="double-link" href="https://github.com/chen3feng/blade-build/commit/cf22752cd6fcee22a6e85b599652a39c4c07c4cf">cf22752cd</a><a href="https://github.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00ccf8868ca">&amp;quot;&amp;gt;cf22752cd&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;cf22752cd&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/chen3feng/blade-build/commit/eba716809459c8ff64082a8d8866c00ccf886&lt;/a&gt;8ca&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/<a class="double-link" href="https://github.com/chen3feng/blade-build/commit/217c2ab81">217c2ab81">217c2ab81</a>

Pull Request Pull Request #616: Remove scons related code

Run Details

56 of 56 new or added lines in 14 files covered. (100.0%)

2616 of 6785 relevant lines covered (38.56%)

0.39 hits per line

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

17.67

/src/blade/proto_library_target.py

# Copyright (c) 2013 Tencent Inc.
# All rights reserved.
#
# Author: Feng Chen <phongchen@tencent.com>


"""Define proto_library target
"""

from __future__ import absolute_import

import os
import re

from blade import build_manager
from blade import build_rules
from blade import config
from blade import console
from blade import java_targets
from blade.blade_util import var_to_list, iteritems
from blade.cc_targets import CcTarget


class ProtocPlugin(object):
    """A helper class for protoc plugin.

    Currently blade only supports protoc plugin which generates
    code by use of @@protoc_insertion_point mechanism. See
    https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.compiler.plugin.pb
    for more details.

    """

    __languages = ['cpp', 'java', 'python']

    def __init__(self,
                 name,
                 path,
                 code_generation):
        self.name = name
        self.path = path
        assert isinstance(code_generation, dict)
        self.code_generation = {}
        for language, v in iteritems(code_generation):
            if language not in self.__languages:
                console.error_exit('%s: Language %s is invalid. '
                                   'Protoc plugins in %s are supported by blade currently.' % (
                                       name, language, ', '.join(self.__languages)))
            self.code_generation[language] = {}
            # Note that each plugin dep should be in the global target format
            # since protoc plugin is defined in the global scope
            deps = []
            for dep in var_to_list(v['deps']):
                if dep.startswith('//'):
                    dep = dep[2:]
                key = tuple(dep.split(':'))
                if key not in deps:
                    deps.append(key)
            self.code_generation[language]['deps'] = deps

    def protoc_plugin_flag(self, out):
        return '--plugin=protoc-gen-%s=%s --%s_out=%s' % (
            self.name, self.path, self.name, out)


class ProtoLibrary(CcTarget, java_targets.JavaTargetMixIn):
    """
    This class manages build rules and dependencies in different languages for proto files.
    """

    def __init__(self,
                 name,
                 srcs,
                 deps,
                 optimize,
                 deprecated,
                 generate_descriptors,
                 target_languages,
                 plugins,
                 source_encoding,
                 blade,
                 kwargs):
        """Init method.

        Init the proto target.

        """
        # pylint: disable=too-many-locals
        srcs = var_to_list(srcs)
        CcTarget.__init__(self,
                          name,
                          'proto_library',
                          srcs,
                          deps,
                          None,
                          '',
                          [], [], [], optimize, [], [],
                          blade,
                          kwargs)

        self._check_proto_srcs_name(srcs)
        if srcs:
            self.data['public_protos'] = [self._source_file_path(s) for s in srcs]

        proto_config = config.get_section('proto_library_config')
        protobuf_libs = var_to_list(proto_config['protobuf_libs'])
        protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])
        protobuf_python_libs = var_to_list(proto_config['protobuf_python_libs'])

        # Hardcode deps rule to thirdparty protobuf lib.
        self._add_hardcode_library(protobuf_libs)
        self._add_hardcode_java_library(protobuf_java_libs)
        self._add_hardcode_library(protobuf_python_libs)

        # Normally a proto target depends on another proto target when
        # it references a message defined in that target. Then in the
        # generated code there is public API with return type/arguments
        # defined outside and in java it needs to export that dependency,
        # which is also the case for java protobuf library.
        self.data['exported_deps'] = self._unify_deps(var_to_list(deps))
        self.data['exported_deps'] += self._unify_deps(protobuf_java_libs)

        self._handle_protoc_plugins(var_to_list(plugins))

        # Link all the symbols by default
        self.data['link_all_symbols'] = True
        self.data['deprecated'] = deprecated
        self.data['source_encoding'] = source_encoding
        self.data['java_sources_explict_dependency'] = []
        self.data['python_vars'] = []
        self.data['python_sources'] = []
        self.data['generate_descriptors'] = generate_descriptors

        # TODO(chen3feng): Change the values to a `set` rather than separated attributes
        target_languages = set(var_to_list(target_languages))
        self.data['generate_java'] = 'java' in target_languages
        self.data['generate_python'] = 'python' in target_languages
        self.data['generate_go'] = 'go' in target_languages

    def _check_proto_srcs_name(self, srcs):
        """Checks whether the proto file's name ends with 'proto'. """
        for src in srcs:
            if not src.endswith('.proto'):
                self.error_exit('Invalid proto file name %s' % src)

    def _check_proto_deps(self):
        """Only proto_library or gen_rule target is allowed as deps. """
        proto_config = config.get_section('proto_library_config')
        protobuf_libs = var_to_list(proto_config['protobuf_libs'])
        protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])
        protobuf_libs = [self._unify_dep(d) for d in protobuf_libs + protobuf_java_libs]
        proto_deps = protobuf_libs + self.data['protoc_plugin_deps']
        for dkey in self.deps:
            if dkey in proto_deps:
                continue
            dep = self.target_database[dkey]
            if dep.type != 'proto_library' and dep.type != 'gen_rule':
                self.error_exit('Invalid dep %s. Proto_library can only depend on proto_library '
                                'or gen_rule.' % dep.fullname)

    def _handle_protoc_plugins(self, plugins):
        """Handle protoc plugins and corresponding dependencies. """
        protoc_plugin_config = config.get_section('protoc_plugin_config')
        protoc_plugins = []
        protoc_plugin_deps, protoc_plugin_java_deps = set(), set()
        for plugin in plugins:
            if plugin not in protoc_plugin_config:
                self.error_exit('Unknown plugin %s' % plugin)
            p = protoc_plugin_config[plugin]
            protoc_plugins.append(p)
            for language, v in iteritems(p.code_generation):
                for key in v['deps']:
                    if key not in self.deps:
                        self.deps.append(key)
                    if key not in self.expanded_deps:
                        self.expanded_deps.append(key)
                    protoc_plugin_deps.add(key)
                    if language == 'java':
                        protoc_plugin_java_deps.add(key)
        self.data['protoc_plugin_deps'] = list(protoc_plugin_deps)
        self.data['exported_deps'] += list(protoc_plugin_java_deps)
        self.data['protoc_plugins'] = protoc_plugins

    def _prepare_to_generate_rule(self):
        CcTarget._prepare_to_generate_rule(self)
        self._check_proto_deps()

    def _expand_deps_generation(self):
        if self.data['generate_java']:
            self._expand_deps_java_generation()

    def _proto_gen_files(self, src):
        """_proto_gen_files. """
        proto_name = src[:-6]
        return (self._target_file_path('%s.pb.cc' % proto_name),
                self._target_file_path('%s.pb.h' % proto_name))

    def _proto_gen_php_file(self, src):
        """Generate the php file name. """
        proto_name = src[:-6]
        return self._target_file_path('%s.pb.php' % proto_name)

    def _proto_gen_python_file(self, src):
        """Generate the python file name. """
        proto_name = src[:-6]
        return self._target_file_path('%s_pb2.py' % proto_name)

    def _proto_gen_go_file(self, src):
        """Generate the go file name. """
        proto_name = src[:-6]
        return self._target_file_path('%s.pb.go' % proto_name)

    def _proto_gen_descriptor_file(self, name):
        """Generate the descriptor file name. """
        return self._target_file_path('%s.descriptors.pb' % name)

    def _get_java_pack_deps(self):
        return self._get_pack_deps()

    def _get_java_package_name(self, content):
        """Get the java package name from proto file if it is specified. """
        java_package_pattern = r'^\s*option\s+java_package\s*=\s*["\']([\w.]+)'
        m = re.search(java_package_pattern, content, re.MULTILINE)
        if m:
            return m.group(1)

        package_pattern = r'^\s*package\s+([\w.]+)'
        m = re.search(package_pattern, content, re.MULTILINE)
        if m:
            return m.group(1)

        return ''

    def _get_go_package_name(self, path):
        with open(path) as f:
            content = f.read()
        pattern = r'^\s*option\s+go_package\s*=\s*"([\w./]+)";'
        m = re.search(pattern, content, re.MULTILINE)
        if m:
            return m.group(1)
        else:
            self.error_exit('"go_package" is mandatory to generate golang code '
                            'in protocol buffers but is missing in %s.' % path)

    def _proto_java_gen_class_name(self, src, content):
        """Get generated java class name"""
        pattern = r'^\s*option\s+java_outer_classname\s*=\s*[\'"](\w+)["\']'
        m = re.search(pattern, content, re.MULTILINE)
        if m:
            return m.group(1)
        proto_name = src[:-6]
        base_name = os.path.basename(proto_name)
        return ''.join([p[0].upper() + p[1:] for p in base_name.split('_') if p])

    def _proto_java_gen_file(self, src):
        """Generate the java files name of the proto library. """
        with open(self._source_file_path(src)) as f:
            content = f.read()
        package_dir = self._get_java_package_name(content).replace('.', '/')
        class_name = self._proto_java_gen_class_name(src, content)
        java_name = '%s.java' % class_name
        return package_dir, java_name

    def protoc_direct_dependencies(self):
        protos = self.data.get('public_protos')[:]
        for key in self.deps:
            dep = self.target_database[key]
            protos += dep.data.get('public_protos', [])
        return protos

    def ninja_proto_descriptor_rules(self):
        inputs = [self._source_file_path(s) for s in self.srcs]
        output = self._proto_gen_descriptor_file(self.name)
        self.ninja_build('protodescriptors', output, inputs=inputs, variables={'first': inputs[0]})

    def ninja_protoc_plugin_parameters(self, language):
        """Return a tuple of (plugin path, vars) used as parameters for ninja build. """
        path, vars = '', {}
        for p in self.data['protoc_plugins']:
            if language in p.code_generation:
                path = p.path
                flag = p.protoc_plugin_flag(self.build_path)
                vars = {'protoc%spluginflags' % language: flag}
                break
        return path, vars

    def ninja_protoc_direct_dependencies(self, vars):
        if config.get_item('proto_library_config', 'protoc_direct_dependencies'):
            dependencies = self.protoc_direct_dependencies()
            dependencies += config.get_item('proto_library_config', 'well_known_protos')
            vars['protocflags'] = '--direct_dependencies %s' % ':'.join(dependencies)

    def ninja_proto_java_rules(self):
        java_sources, implicit_deps = [], []
        plugin, vars = self.ninja_protoc_plugin_parameters('java')
        if plugin:
            implicit_deps.append(plugin)
        for src in self.srcs:
            input = self._source_file_path(src)
            package_dir, java_name = self._proto_java_gen_file(src)
            output = self._target_file_path(os.path.join(os.path.dirname(src), package_dir, java_name))
            self.ninja_build('protojava', output, inputs=input,
                             implicit_deps=implicit_deps, variables=vars)
            java_sources.append(output)

        jar = self.ninja_build_jar(inputs=java_sources,
                                   source_encoding=self.data.get('source_encoding'))
        self._add_target_file('jar', jar)

    def ninja_proto_python_rules(self):
        # plugin, vars = self.ninja_protoc_plugin_parameters('python')
        generated_pys = []
        for proto in self.srcs:
            input = self._source_file_path(proto)
            output = self._proto_gen_python_file(proto)
            self.ninja_build('protopython', output, inputs=input)
            generated_pys.append(output)
        pylib = self._target_file_path() + '.pylib'
        self.ninja_build('pythonlibrary', pylib, inputs=generated_pys,
                         variables={'pythonbasedir': self.build_path})
        self._add_target_file('pylib', pylib)

    def ninja_proto_go_rules(self):
        go_home = config.get_item('go_config', 'go_home')
        protobuf_go_path = config.get_item('proto_library_config', 'protobuf_go_path')
        generated_goes = []
        for src in self.srcs:
            path = self._source_file_path(src)
            package = self._get_go_package_name(path)
            if not package.startswith(protobuf_go_path):
                self.warning('go_package "%s" is not starting with "%s" in %s' % (
                             package, protobuf_go_path, src))
            basename = os.path.basename(src)
            output = os.path.join(go_home, 'src', package, '%s.pb.go' % basename[:-6])
            self.ninja_build('protogo', output, inputs=path)
            generated_goes.append(output)
        self._add_target_file('gopkg', generated_goes)

    def ninja_proto_rules(self, options):
        """Generate ninja rules for other languages if needed. """
        if (getattr(options, 'generate_java', False) or
                self.data.get('generate_java') or
                self.data.get('generate_scala')):
            self.ninja_proto_java_rules()

        if (getattr(options, 'generate_python', False) or
                self.data.get('generate_python')):
            self.ninja_proto_python_rules()

        if (getattr(options, 'generate_go', False) or
                self.data.get('generate_go')):
            self.ninja_proto_go_rules()

        if self.data['generate_descriptors']:
            self.ninja_proto_descriptor_rules()

    def _proto_gen_file_names(self, source):
        base = source[:-6]
        return ['%s.pb.h' % base, '%s.pb.cc' % base]

    def ninja_rules(self):
        """Generate ninja rules for proto files. """
        self._check_deprecated_deps()
        self._check_proto_deps()
        if not self.srcs:
            return

        plugin, vars = self.ninja_protoc_plugin_parameters('cpp')
        self.ninja_protoc_direct_dependencies(vars)
        cpp_sources, cpp_headers, implicit_deps = [], [], []
        if plugin:
            implicit_deps.append(plugin)
        for src in self.srcs:
            source, header = self._proto_gen_files(src)
            self.ninja_build('proto', [source, header],
                             inputs=self._source_file_path(src),
                             implicit_deps=implicit_deps, variables=vars)
            cpp_headers.append(header)
            self.data['generated_hdrs'].append(header)
            names = self._proto_gen_file_names(src)
            cpp_sources.append(names[1])
        self._cc_objects_ninja(cpp_sources, True, generated_headers=cpp_headers)
        self._cc_library_ninja()
        self.ninja_proto_rules(self.blade.get_options())


def proto_library(name,
                  srcs=[],
                  deps=[],
                  optimize=[],
                  deprecated=False,
                  generate_descriptors=False,
                  target_languages=None,
                  plugins=[],
                  source_encoding='iso-8859-1',
                  **kwargs):
    """proto_library target.
    Args:
        generate_descriptors (bool): Whether generate binary protobuf descriptors.
        target_languages (Sequence[str]): Code for target languages to be generated, such as
            `java`, `python`, see protoc's `--xx_out`s.
            NOTE: The `cpp` target code is always generated.
    """
    proto_library_target = ProtoLibrary(name,
                                        srcs,
                                        deps,
                                        optimize,
                                        deprecated,
                                        generate_descriptors,
                                        target_languages,
                                        plugins,
                                        source_encoding,
                                        build_manager.instance,
                                        kwargs)
    build_manager.instance.register_target(proto_library_target)


build_rules.register_function(proto_library)

1	# Copyright (c) 2013 Tencent Inc.
2	# All rights reserved.
3	#
4	# Author: Feng Chen <phongchen@tencent.com>
5
6
7	"""Define proto_library target	1✔
8	"""
9
10	from __future__ import absolute_import	1✔
11
12	import os	1✔
13	import re	1✔
14
15	from blade import build_manager	1✔
16	from blade import build_rules	1✔
17	from blade import config	1✔
18	from blade import console	1✔
19	from blade import java_targets	1✔
20	from blade.blade_util import var_to_list, iteritems	1✔
21	from blade.cc_targets import CcTarget	1✔
22
23
24	class ProtocPlugin(object):	1✔
25	"""A helper class for protoc plugin.
26
27	Currently blade only supports protoc plugin which generates
28	code by use of @@protoc_insertion_point mechanism. See
29	https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.compiler.plugin.pb
30	for more details.
31
32	"""
33
34	__languages = ['cpp', 'java', 'python']	1✔
35
36	def __init__(self,	1✔
37	name,
38	path,
39	code_generation):
40	self.name = name	×
41	self.path = path	×
42	assert isinstance(code_generation, dict)	×
43	self.code_generation = {}	×
44	for language, v in iteritems(code_generation):	×
45	if language not in self.__languages:	×
46	console.error_exit('%s: Language %s is invalid. '	×
47	'Protoc plugins in %s are supported by blade currently.' % (
48	name, language, ', '.join(self.__languages)))
49	self.code_generation[language] = {}	×
50	# Note that each plugin dep should be in the global target format
51	# since protoc plugin is defined in the global scope
52	deps = []	×
53	for dep in var_to_list(v['deps']):	×
54	if dep.startswith('//'):	×
55	dep = dep[2:]	×
56	key = tuple(dep.split(':'))	×
57	if key not in deps:	×
58	deps.append(key)	×
59	self.code_generation[language]['deps'] = deps	×
60
61	def protoc_plugin_flag(self, out):	1✔
62	return '--plugin=protoc-gen-%s=%s --%s_out=%s' % (	×
63	self.name, self.path, self.name, out)
64
65
66	class ProtoLibrary(CcTarget, java_targets.JavaTargetMixIn):	1✔
67	"""
68	This class manages build rules and dependencies in different languages for proto files.
69	"""
70
71	def __init__(self,	1✔
72	name,
73	srcs,
74	deps,
75	optimize,
76	deprecated,
77	generate_descriptors,
78	target_languages,
79	plugins,
80	source_encoding,
81	blade,
82	kwargs):
83	"""Init method.
84
85	Init the proto target.
86
87	"""
88	# pylint: disable=too-many-locals
89	srcs = var_to_list(srcs)	×
90	CcTarget.__init__(self,	×
91	name,
92	'proto_library',
93	srcs,
94	deps,
95	None,
96	'',
97	[], [], [], optimize, [], [],
98	blade,
99	kwargs)
100
101	self._check_proto_srcs_name(srcs)	×
102	if srcs:	×
103	self.data['public_protos'] = [self._source_file_path(s) for s in srcs]	×
104
105	proto_config = config.get_section('proto_library_config')	×
106	protobuf_libs = var_to_list(proto_config['protobuf_libs'])	×
107	protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])	×
108	protobuf_python_libs = var_to_list(proto_config['protobuf_python_libs'])	×
109
110	# Hardcode deps rule to thirdparty protobuf lib.
111	self._add_hardcode_library(protobuf_libs)	×
112	self._add_hardcode_java_library(protobuf_java_libs)	×
113	self._add_hardcode_library(protobuf_python_libs)	×
114
115	# Normally a proto target depends on another proto target when
116	# it references a message defined in that target. Then in the
117	# generated code there is public API with return type/arguments
118	# defined outside and in java it needs to export that dependency,
119	# which is also the case for java protobuf library.
120	self.data['exported_deps'] = self._unify_deps(var_to_list(deps))	×
121	self.data['exported_deps'] += self._unify_deps(protobuf_java_libs)	×
122
123	self._handle_protoc_plugins(var_to_list(plugins))	×
124
125	# Link all the symbols by default
126	self.data['link_all_symbols'] = True	×
127	self.data['deprecated'] = deprecated	×
128	self.data['source_encoding'] = source_encoding	×
129	self.data['java_sources_explict_dependency'] = []	×
130	self.data['python_vars'] = []	×
131	self.data['python_sources'] = []	×
132	self.data['generate_descriptors'] = generate_descriptors	×
133
134	# TODO(chen3feng): Change the values to a `set` rather than separated attributes
135	target_languages = set(var_to_list(target_languages))	×
136	self.data['generate_java'] = 'java' in target_languages	×
137	self.data['generate_python'] = 'python' in target_languages	×
138	self.data['generate_go'] = 'go' in target_languages	×
139
140	def _check_proto_srcs_name(self, srcs):	1✔
141	"""Checks whether the proto file's name ends with 'proto'. """
142	for src in srcs:	×
143	if not src.endswith('.proto'):	×
144	self.error_exit('Invalid proto file name %s' % src)	×
145
146	def _check_proto_deps(self):	1✔
147	"""Only proto_library or gen_rule target is allowed as deps. """
148	proto_config = config.get_section('proto_library_config')	×
149	protobuf_libs = var_to_list(proto_config['protobuf_libs'])	×
150	protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])	×
151	protobuf_libs = [self._unify_dep(d) for d in protobuf_libs + protobuf_java_libs]	×
152	proto_deps = protobuf_libs + self.data['protoc_plugin_deps']	×
153	for dkey in self.deps:	×
154	if dkey in proto_deps:	×
155	continue	×
156	dep = self.target_database[dkey]	×
157	if dep.type != 'proto_library' and dep.type != 'gen_rule':	×
158	self.error_exit('Invalid dep %s. Proto_library can only depend on proto_library '	×
159	'or gen_rule.' % dep.fullname)
160
161	def _handle_protoc_plugins(self, plugins):	1✔
162	"""Handle protoc plugins and corresponding dependencies. """
163	protoc_plugin_config = config.get_section('protoc_plugin_config')	×
164	protoc_plugins = []	×
165	protoc_plugin_deps, protoc_plugin_java_deps = set(), set()	×
166	for plugin in plugins:	×
167	if plugin not in protoc_plugin_config:	×
168	self.error_exit('Unknown plugin %s' % plugin)	×
169	p = protoc_plugin_config[plugin]	×
170	protoc_plugins.append(p)	×
171	for language, v in iteritems(p.code_generation):	×
172	for key in v['deps']:	×
173	if key not in self.deps:	×
174	self.deps.append(key)	×
175	if key not in self.expanded_deps:	×
176	self.expanded_deps.append(key)	×
177	protoc_plugin_deps.add(key)	×
178	if language == 'java':	×
179	protoc_plugin_java_deps.add(key)	×
180	self.data['protoc_plugin_deps'] = list(protoc_plugin_deps)	×
181	self.data['exported_deps'] += list(protoc_plugin_java_deps)	×
182	self.data['protoc_plugins'] = protoc_plugins	×
183
184	def _prepare_to_generate_rule(self):	1✔
185	CcTarget._prepare_to_generate_rule(self)	×
186	self._check_proto_deps()	×
187
188	def _expand_deps_generation(self):	1✔
189	if self.data['generate_java']:	×
190	self._expand_deps_java_generation()	×
191
192	def _proto_gen_files(self, src):	1✔
193	"""_proto_gen_files. """
194	proto_name = src[:-6]	×
195	return (self._target_file_path('%s.pb.cc' % proto_name),	×
196	self._target_file_path('%s.pb.h' % proto_name))
197
198	def _proto_gen_php_file(self, src):	1✔
199	"""Generate the php file name. """
200	proto_name = src[:-6]	×
201	return self._target_file_path('%s.pb.php' % proto_name)	×
202
203	def _proto_gen_python_file(self, src):	1✔
204	"""Generate the python file name. """
205	proto_name = src[:-6]	×
206	return self._target_file_path('%s_pb2.py' % proto_name)	×
207
208	def _proto_gen_go_file(self, src):	1✔
209	"""Generate the go file name. """
210	proto_name = src[:-6]	×
211	return self._target_file_path('%s.pb.go' % proto_name)	×
212
213	def _proto_gen_descriptor_file(self, name):	1✔
214	"""Generate the descriptor file name. """
215	return self._target_file_path('%s.descriptors.pb' % name)	×
216
217	def _get_java_pack_deps(self):	1✔
218	return self._get_pack_deps()	×
219
220	def _get_java_package_name(self, content):	1✔
221	"""Get the java package name from proto file if it is specified. """
222	java_package_pattern = r'^\soption\s+java_package\s=\s*["\']([\w.]+)'	×
223	m = re.search(java_package_pattern, content, re.MULTILINE)	×
224	if m:	×
225	return m.group(1)	×
226
227	package_pattern = r'^\s*package\s+([\w.]+)'	×
228	m = re.search(package_pattern, content, re.MULTILINE)	×
229	if m:	×
230	return m.group(1)	×
231
232	return ''	×
233
234	def _get_go_package_name(self, path):	1✔
235	with open(path) as f:	×
236	content = f.read()	×
237	pattern = r'^\soption\s+go_package\s=\s*"([\w./]+)";'	×
238	m = re.search(pattern, content, re.MULTILINE)	×
239	if m:	×
240	return m.group(1)	×
241	else:
242	self.error_exit('"go_package" is mandatory to generate golang code '	×
243	'in protocol buffers but is missing in %s.' % path)
244
245	def _proto_java_gen_class_name(self, src, content):	1✔
246	"""Get generated java class name"""
247	pattern = r'^\soption\s+java_outer_classname\s=\s*[\'"](\w+)["\']'	×
248	m = re.search(pattern, content, re.MULTILINE)	×
249	if m:	×
250	return m.group(1)	×
251	proto_name = src[:-6]	×
252	base_name = os.path.basename(proto_name)	×
253	return ''.join([p[0].upper() + p[1:] for p in base_name.split('_') if p])	×
254
255	def _proto_java_gen_file(self, src):	1✔
256	"""Generate the java files name of the proto library. """
257	with open(self._source_file_path(src)) as f:	×
258	content = f.read()	×
259	package_dir = self._get_java_package_name(content).replace('.', '/')	×
260	class_name = self._proto_java_gen_class_name(src, content)	×
261	java_name = '%s.java' % class_name	×
262	return package_dir, java_name	×
263
264	def protoc_direct_dependencies(self):	1✔
265	protos = self.data.get('public_protos')[:]	×
266	for key in self.deps:	×
267	dep = self.target_database[key]	×
268	protos += dep.data.get('public_protos', [])	×
269	return protos	×
270
271	def ninja_proto_descriptor_rules(self):	1✔
272	inputs = [self._source_file_path(s) for s in self.srcs]	×
273	output = self._proto_gen_descriptor_file(self.name)	×
274	self.ninja_build('protodescriptors', output, inputs=inputs, variables={'first': inputs[0]})	×
275
276	def ninja_protoc_plugin_parameters(self, language):	1✔
277	"""Return a tuple of (plugin path, vars) used as parameters for ninja build. """
278	path, vars = '', {}	×
279	for p in self.data['protoc_plugins']:	×
280	if language in p.code_generation:	×
281	path = p.path	×
282	flag = p.protoc_plugin_flag(self.build_path)	×
283	vars = {'protoc%spluginflags' % language: flag}	×
284	break	×
285	return path, vars	×
286
287	def ninja_protoc_direct_dependencies(self, vars):	1✔
288	if config.get_item('proto_library_config', 'protoc_direct_dependencies'):	×
289	dependencies = self.protoc_direct_dependencies()	×
290	dependencies += config.get_item('proto_library_config', 'well_known_protos')	×
291	vars['protocflags'] = '--direct_dependencies %s' % ':'.join(dependencies)	×
292
293	def ninja_proto_java_rules(self):	1✔
294	java_sources, implicit_deps = [], []	×
295	plugin, vars = self.ninja_protoc_plugin_parameters('java')	×
296	if plugin:	×
297	implicit_deps.append(plugin)	×
298	for src in self.srcs:	×
299	input = self._source_file_path(src)	×
300	package_dir, java_name = self._proto_java_gen_file(src)	×
301	output = self._target_file_path(os.path.join(os.path.dirname(src), package_dir, java_name))	×
302	self.ninja_build('protojava', output, inputs=input,	×
303	implicit_deps=implicit_deps, variables=vars)
304	java_sources.append(output)	×
305
306	jar = self.ninja_build_jar(inputs=java_sources,	×
307	source_encoding=self.data.get('source_encoding'))
308	self._add_target_file('jar', jar)	×
309
310	def ninja_proto_python_rules(self):	1✔
311	# plugin, vars = self.ninja_protoc_plugin_parameters('python')
312	generated_pys = []	×
313	for proto in self.srcs:	×
314	input = self._source_file_path(proto)	×
315	output = self._proto_gen_python_file(proto)	×
316	self.ninja_build('protopython', output, inputs=input)	×
317	generated_pys.append(output)	×
318	pylib = self._target_file_path() + '.pylib'	×
319	self.ninja_build('pythonlibrary', pylib, inputs=generated_pys,	×
320	variables={'pythonbasedir': self.build_path})
321	self._add_target_file('pylib', pylib)	×
322
323	def ninja_proto_go_rules(self):	1✔
324	go_home = config.get_item('go_config', 'go_home')	×
325	protobuf_go_path = config.get_item('proto_library_config', 'protobuf_go_path')	×
326	generated_goes = []	×
327	for src in self.srcs:	×
328	path = self._source_file_path(src)	×
329	package = self._get_go_package_name(path)	×
330	if not package.startswith(protobuf_go_path):	×
331	self.warning('go_package "%s" is not starting with "%s" in %s' % (	×
332	package, protobuf_go_path, src))
333	basename = os.path.basename(src)	×
334	output = os.path.join(go_home, 'src', package, '%s.pb.go' % basename[:-6])	×
335	self.ninja_build('protogo', output, inputs=path)	×
336	generated_goes.append(output)	×
337	self._add_target_file('gopkg', generated_goes)	×
338
339	def ninja_proto_rules(self, options):	1✔
340	"""Generate ninja rules for other languages if needed. """
341	if (getattr(options, 'generate_java', False) or	×
342	self.data.get('generate_java') or
343	self.data.get('generate_scala')):
344	self.ninja_proto_java_rules()	×
345
346	if (getattr(options, 'generate_python', False) or	×
347	self.data.get('generate_python')):
348	self.ninja_proto_python_rules()	×
349
350	if (getattr(options, 'generate_go', False) or	×
351	self.data.get('generate_go')):
352	self.ninja_proto_go_rules()	×
353
354	if self.data['generate_descriptors']:	×
355	self.ninja_proto_descriptor_rules()	×
356
357	def _proto_gen_file_names(self, source):	1✔
358	base = source[:-6]	×
359	return ['%s.pb.h' % base, '%s.pb.cc' % base]	×
360
361	def ninja_rules(self):	1✔
362	"""Generate ninja rules for proto files. """
363	self._check_deprecated_deps()	×
364	self._check_proto_deps()	×
365	if not self.srcs:	×
366	return	×
367
368	plugin, vars = self.ninja_protoc_plugin_parameters('cpp')	×
369	self.ninja_protoc_direct_dependencies(vars)	×
370	cpp_sources, cpp_headers, implicit_deps = [], [], []	×
371	if plugin:	×
372	implicit_deps.append(plugin)	×
373	for src in self.srcs:	×
374	source, header = self._proto_gen_files(src)	×
375	self.ninja_build('proto', [source, header],	×
376	inputs=self._source_file_path(src),
377	implicit_deps=implicit_deps, variables=vars)
378	cpp_headers.append(header)	×
379	self.data['generated_hdrs'].append(header)	×
380	names = self._proto_gen_file_names(src)	×
381	cpp_sources.append(names[1])	×
382	self._cc_objects_ninja(cpp_sources, True, generated_headers=cpp_headers)	×
383	self._cc_library_ninja()	×
384	self.ninja_proto_rules(self.blade.get_options())	×
385
386
387	def proto_library(name,	1✔
388	srcs=[],
389	deps=[],
390	optimize=[],
391	deprecated=False,
392	generate_descriptors=False,
393	target_languages=None,
394	plugins=[],
395	source_encoding='iso-8859-1',
396	**kwargs):
397	"""proto_library target.
398	Args:
399	generate_descriptors (bool): Whether generate binary protobuf descriptors.
400	target_languages (Sequence[str]): Code for target languages to be generated, such as
401	`java`, `python`, see protoc's `--xx_out`s.
402	NOTE: The `cpp` target code is always generated.
403	"""
404	proto_library_target = ProtoLibrary(name,	×
405	srcs,
406	deps,
407	optimize,
408	deprecated,
409	generate_descriptors,
410	target_languages,
411	plugins,
412	source_encoding,
413	build_manager.instance,
414	kwargs)
415	build_manager.instance.register_target(proto_library_target)	×
416
417
418	build_rules.register_function(proto_library)	1✔

chen3feng / blade-build / 572

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