def generate_project(project_path, project_name):
project = Project(project_name)
extensions = [Package('opencv')]
configure_gcc(gcc_command='g++', ccache=False)
compile = Phase()
compile.executor = GccCompile()
compile.extensions += extensions
compile.inputs = glob(project_path + '*.cpp')
compile.executor.hooks.append(debug_hook)
link = Phase()
link.executor = GccLink()
link.inputs_from.append(compile)
link.extensions += extensions
link.output = 'opencv'
link.executor.hooks.append(debug_hook)
if ctx.build.run:
link.run_output = 1
argv = str(ctx.get('args.argv'))
print("Running with " + argv)
to_run = ["{output}", argv]
link.run_command = to_run
project.phases['link'] = link
project.phases['compile'] = compile
return project
from ronin.extensions import OutputsExtension
from ronin.phases import Phase
from ronin.projects import Project
from ronin.utils.paths import glob, input_path
with new_context() as ctx:
# Library
library = Project('gcc Multi-Project Example: Library', file_name='library')
executor = GccBuild()
executor.create_shared_library()
executor.pic()
Phase(project=library,
name='build',
executor=executor,
inputs=glob('src/foo/**/*.c'),
output='foo')
# Main
main = Project('Multi-Project Example: Main', file_name='main')
executor = GccBuild()
executor.add_include_path(input_path('src/foo'))
executor.linker_rpath_origin() # to load the .so file from executable's directory
Phase(project=main,
name='build',
executor=executor,
inputs=glob('src/main/**/*.c'),
extensions=[OutputsExtension(library, 'build')],
output='main',
run_output=1 if ctx.build.run else 0)
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.files import Copy
from ronin.gcc import GccBuild
from ronin.phases import Phase
from ronin.projects import Project
from ronin.sdl import SDL
from ronin.utils.paths import glob
with new_context() as ctx:
project = Project('gcc SDL Hello World')
static = (ctx.get('sdl.static') == 'true')
Phase(project=project,
name='build',
executor=GccBuild(),
inputs=glob('src/**/*.c'),
extensions=[SDL(static=static)],
output='hello',
run_output=1 if ctx.build.run else 0)
Phase(project=project,
name='resource',
executor=Copy(),
input_path_relative='res',
inputs=glob('res/**'))
cli(project)
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.java import JavaCompile, Jar, JavaClasses
from ronin.phases import Phase
from ronin.projects import Project
from ronin.utils.paths import glob, input_path, join_path
from ronin.utils.platform import which
with new_context() as ctx:
project = Project('Java Swing Hello World')
# Compile
Phase(project=project,
name='compile',
executor=JavaCompile(),
input_path=join_path(ctx.paths.root, 'src'),
inputs=glob('**/*.java'))
# Jar
Phase(project=project,
name='jar',
executor=Jar(manifest=input_path('MANIFEST.MF')),
extensions=[JavaClasses(project, 'compile')],
output='hello',
run_output=1 if ctx.build.run else 0,
run_command=[which('java'), '-jar', '{output}'])
cli(project)
# Ubuntu: sudo apt install gcc ccache
#
# Rōnin supports Unicode.
#
# Note the magic "coding" comment at the top of this file, which tells Python to read the file in
# that encoding. Furthermore, we need to use the "u" prefix for literal strings that contain
# Unicode characters. That's pretty much all you need to do: the Ninja file is always created in
# UTF-8 by default. (To change its encoding, set "ninja.encoding" in the context.)
#
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.gcc import GccBuild
from ronin.phases import Phase
from ronin.projects import Project
from ronin.utils.paths import glob
with new_context() as ctx:
project = Project(u'浪人 gcc Unicode Example')
Phase(
project=project,
name='build', # cannot be Unicode!
executor=GccBuild(),
inputs=glob(u'ソース/**/*.c'),
output='長さ',
run_output=1 if ctx.build.run else 0)
cli(project)
#
# This is the simplest possible version, using a single build phase and all the defaults.
#
# A single build phase works fine, and may be the best solution for small projects. However, it does
# not make use of Ninja's ability to parallelize builds, and to track changes to individual files
# ("incremental" builds). Larger projects would generally build faster will a two-phase
# (compile/link) build. See build2.py for an example.
#
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.gcc import GccBuild
from ronin.phases import Phase
from ronin.pkg_config import Package
from ronin.projects import Project
from ronin.utils.paths import glob
with new_context(output_path_relative='build1') as ctx:
project = Project('gcc GTK+ Hello World')
Phase(project=project,
name='build',
executor=GccBuild(),
inputs=glob('src/**/*.c'),
extensions=[Package('gtk+-3.0')],
output='example_1',
run_output=1 if ctx.build.run else 0)
cli(project)
else:
executor.enable_debug()
executor.optimize('0')
with new_context() as ctx:
project = Project('Genetic-Algo')
# extensions = [Package('OpenCV')]
extensions = []
configure_gcc(gcc_command='g++', ccache=False)
compile = Phase()
compile.executor = GccCompile()
compile.extensions += extensions
compile.inputs = glob('**/*.cpp')
compile.executor.hooks.append(debug_hook)
compile.executor.enable_warning(value='all')
link = Phase()
link.executor = GccLink()
link.inputs_from.append(compile)
link.extensions += extensions
link.output = 'gen-algo'
link.executor.hooks.append(debug_hook)
if ctx.build.run:
link.run_output = 1
project.phases['link'] = link
project.phases['compile'] = compile
# ValaPackage to make sure you configure your packages correctly for four-phase builds.
#
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.gcc import GccLink
from ronin.phases import Phase
from ronin.projects import Project
from ronin.vala import ValaApi, ValaTranspile, ValaGccCompile, ValaPackage
from ronin.utils.paths import glob
with new_context(output_path_relative='build2') as ctx:
project = Project('Vala GTK+ Hello World')
inputs = glob('src/**/*.vala')
extensions = [ValaPackage('gtk+-3.0')]
# API
executor = ValaApi()
executor.enable_deprecated()
Phase(project=project, name='api', executor=ValaApi(), inputs=inputs)
# Transpile
Phase(project=project,
name='transpile',
executor=ValaTranspile(apis=['api']),
inputs=inputs,
extensions=extensions)
# Compile
def glob_src(pattern):
return \
glob(pattern + '/*.gs') + \
glob(pattern + '/*.vala')
# "rebuild_on=" with the relevant source files.
#
# This example doesn't really make much use of Ronin, but shows how you can still integrate Cargo
# into a Ronin build script.
#
# Note that the first build will take a minute or two, because Cargo will download and build the
# GTK+ library and its many dependencies. Be patient. You can see them later in
# "target/[release/debug]/deps".
#
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.phases import Phase
from ronin.projects import Project
from ronin.rust import CargoBuild
from ronin.utils.paths import input_path, glob
with new_context(output_path_relative='build2') as ctx:
project = Project('Rust GTK+ Hello World')
Phase(project=project,
name='build',
executor=CargoBuild(),
inputs=[input_path('Cargo.toml')],
rebuild_on=glob('src/hello2.rs'),
output='hello2',
run_output=1 if ctx.build.run else 0)
cli(project)
Phase(project=project,
name='build',
executor=executor,
inputs=inputs,
extensions=extensions,
output=name)
return project
with new_context() as ctx:
dependencies = Dependencies()
khovsgold_inputs = \
glob_src('src/server/**') + \
glob('src/version.gs') + \
glob('src/models.gs') + \
glob('src/iterators.gs') + \
glob('src/utilities.gs') + \
glob_src('src/lib/logging/**') + \
glob_src('src/lib/console/**') + \
glob_src('src/lib/nap/**') + \
glob_src('src/lib/json/**') + \
glob_src('src/lib/avahi/**') + \
glob_src('src/lib/sqlite/**') + \
glob_src('src/lib/gstreamer/**') + \
glob_src('src/lib/daemonize/**') + \
glob_src('src/lib/system/**')
khovsgold_extensions = [
dependencies.libsoup, dependencies.gee, dependencies.json,
def glob_src(pattern):
return \
glob(pattern + '/*.gs') + \
glob(pattern + '/*.vala')
executor.target_glib('2.32')
Phase(project=project,
name='build',
executor=executor,
inputs=inputs,
extensions=extensions,
output=name)
return project
with new_context() as ctx:
dependencies = Dependencies()
khovsgold_inputs = \
glob_src('src/server/**') + \
glob('src/version.gs') + \
glob('src/models.gs') + \
glob('src/iterators.gs') + \
glob('src/utilities.gs') + \
glob_src('src/lib/logging/**') + \
glob_src('src/lib/console/**') + \
glob_src('src/lib/nap/**') + \
glob_src('src/lib/json/**') + \
glob_src('src/lib/avahi/**') + \
glob_src('src/lib/sqlite/**') + \
glob_src('src/lib/gstreamer/**') + \
glob_src('src/lib/daemonize/**') + \
glob_src('src/lib/system/**')
khovsgold_extensions = [
dependencies.libsoup,
columns=100,
strict=False)
configure_gcc(gcc_command='gcc',
ccache=True,
ccache_path='/usr/lib/ccache')
configure_pkg_config(pkg_config_command='pkg-config', pkg_config_path=None)
project = Project('gcc GTK+ Hello World')
extensions = [Package('gtk+-3.0')]
# Compile
comp = Phase()
comp.executor = GccCompile()
comp.inputs = glob('src/**/*.c')
comp.extensions += extensions
project.phases['compile'] = comp
# Link
link = Phase()
link.executor = GccLink()
link.inputs_from.append(comp)
link.extensions += extensions
link.output = 'example_1'
if ctx.build.run:
link.run_output = 1
project.phases['link'] = link
cli(project)
# Rust comes with its own build system, Cargo, which is tightly integrated with the language.
# However, Ronin still provides basic Rust support, which can be useful in projects that combine
# Rust code with other languages.
#
# Note that if you want to easily use dependencies from crates.io, you will need to use Cargo.
# Unfortunately, Cargo cannot be used just to manage dependencies, so you will have to work
# entirely with Cargo.
#
# See build2.py for an example of integration with Cargo.
#
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.phases import Phase
from ronin.projects import Project
from ronin.rust import RustBuild
from ronin.utils.paths import glob
with new_context(output_path_relative='build1') as ctx:
project = Project('Rust Hello World')
Phase(project=project,
name='build',
executor=RustBuild(),
inputs=glob('src/hello1.rs'),
output='hello1',
run_output=1 if ctx.build.run else 0)
cli(project)
from ronin.contexts import new_context
from ronin.gcc import GccCompile, GccLink, GccBuild
from ronin.phases import Phase
from ronin.pkg_config import Package
from ronin.projects import Project
from ronin.utils.paths import glob, join_path
with new_context() as ctx:
project = Project('Testing with Check')
# Compile
Phase(project=project,
name='compile',
executor=GccCompile(),
inputs=glob('src/**/*.c'))
project.phases['compile'].executor.pic()
# Link program
Phase(project=project,
name='link_program',
executor=GccLink(),
inputs_from=['compile'],
output='money',
run_output=2 if ctx.build.run else 0)
if ctx.build.test:
tests_path = join_path(project.get_output_path('binary'), 'tests')
# Link library
Phase(project=project,
columns=100,
strict=False)
utproject = Project(name='Off-target unit tests', variant='ut')
unittestextensions = [Package('gmock_main')]
unittestextensions += [ExplicitExtension(libraries=['pthread'])]
unittestcompile = GccCompile(command='/usr/bin/g++')
unittestcompile.add_argument("-std=c++11")
unittestcompile.add_argument("-ggdb")
unittestcompile.add_include_path('src/unittests/')
unittestcompile.add_include_path('src/robobo/')
unittestcompile.add_include_path('src/FreeRTOS/')
unittestcompile.define("ROBOBO_VERSION_STRING", "\'\"Robobo 0.1\"\'")
unittestlink = GccLink(command='/usr/bin/g++')
unittestsources = glob('src/unittests/*.cpp')
unittestsources += glob('src/robobo/*.cpp')
Phase(project=utproject,
name='utcompile',
executor=unittestcompile,
extensions=unittestextensions,
inputs=unittestsources)
Phase(project=utproject,
name='utlink',
executor=unittestlink,
inputs_from=['utcompile'],
extensions=unittestextensions,
output='unittests',
run_output=1 if ctx.build.run else 0)
from ronin.go import GoCompile, GoLink, GoPackage
from ronin.phases import Phase
from ronin.projects import Project
from ronin.utils.paths import glob
with new_context() as ctx:
project = Project('Go Example')
extensions = [GoPackage(project, 'compile_functions')]
# Compile main package
Phase(project=project,
name='compile_main',
executor=GoCompile(),
inputs=glob('src/main.go'),
extensions=extensions,
output='main')
# Compile functions package
Phase(project=project,
name='compile_functions',
executor=GoCompile(),
inputs=glob('src/functions.go'),
output='ronin/functions')
# Link
Phase(project=project,
name='link',
executor=GoLink(),
inputs_from=['compile_main'],
#
from ronin.cli import cli
from ronin.contexts import new_context
from ronin.gcc import GccBuild
from ronin.phases import Phase
from ronin.pkg_config import Package
from ronin.projects import Project
from ronin.qt import QtMetaObjectCompile
from ronin.utils.paths import glob
with new_context() as ctx:
project = Project('g++ Qt Hello World')
Phase(project=project,
name='meta',
executor=QtMetaObjectCompile(),
inputs=glob('src/**/*.h'))
Phase(project=project,
name='build',
executor=GccBuild('g++'),
inputs=glob('src/**/*.cpp'),
inputs_from=['meta'],
extensions=[Package('QtGui')],
output='hello',
run_output=1 if ctx.build.run else 0)
cli(project)
