Just extraction

.gitignore

@@ -13,3 +13,6 @@ dist
 git-access-testing
 github-access-testing
 *~
+*.idea
+.tox
+*nosetests.xml

docs/reference/buildsystem.md

@@ -273,3 +273,19 @@ subdirectory. Within this directory build products are further divided by the
 name of the [target](tutorial/targets.html) being built. This makes it safe to
 switch between building for different targets without cleaning.
 
+
+## <a href="#export-builds" name="export-builds">#</a> Exporting Builds
+
+Yotta can export the generated file structure to be later built elsewhere using:
+
+```
+yotta build -g -x some/output/path
+```
+
+In this case `-g` is used to stop the local compile from happening immediately,
+and `-x` copies the build files to the specified directory.
+
+To build and link your project you would then have to run the cmake commands
+against that output directory. The generated files use relative paths,
+making them portable; for example to send to an independent build server.
+

docs/reference/commands.md

@@ -80,6 +80,8 @@ Options:
     This option is deprecated because it is now the default, unless
     `--debug-build` is specified.
 
+  * **`--export`, `-x`**: export mode. If flag is set, generates a buildable directory structure at the specified path.
+
   * **`--cmake-generator`, `-G`**: specify the CMake Generator. CMake can generate project files for various editors and IDEs.
 
   * **`name ...`**: one or more modules may be specified, in which case only these

yotta/build.py

@@ -6,6 +6,7 @@
 # standard library modules, , ,
 import os
 import logging
+import shutil
 
 
 # validate, , validate things, internal
@@ -16,6 +17,11 @@
 from yotta.lib import cmakegen
 # Target, , represents an installed target, internal
 from yotta.lib import target
+# settings, , load and save settings, internal
+from yotta.lib import settings
+# paths
+from yotta.lib import paths
+from yotta.lib import fsutils
 # install, , install subcommand, internal
 from yotta import install
 # --config option, , , internal
@@ -27,6 +33,12 @@ def addOptions(parser, add_build_targets=True):
         action='store_true', default=False,
         help='Only generate CMakeLists, don\'t run CMake or build'
     )
+    parser.add_argument('-x', '--export', dest='export',
+        default=False, const=True, nargs='?',
+        help=(
+            'Export mode. If flag is set, generates a buildable directory structure at the specified path.'
+        )
+    )
     parser.add_argument('-r', '--release-build', dest='release_build', action='store_true', default=True)
     parser.add_argument('-d', '--debug-build', dest='release_build', action='store_false', default=True)
     parser.add_argument('-r0', '--release-no-debug-info-build', dest='release_no_debug_info_build', action='store_true', default=False)
@@ -57,16 +69,36 @@ def installAndBuild(args, following_args):
         If status: is nonzero there was some sort of error. Other properties
         are optional, and may not be set if that step was not attempted.
     '''
-    build_status = generate_status = install_status = 0
-
-    if not hasattr(args, 'build_targets'):
-        vars(args)['build_targets'] = []
+    build_status = 0
+    generate_status = 0
+    error = None
+    args_dict = vars(args)
+    export_mode_or_path = args_dict.get('export')
+
+    if export_mode_or_path:
+        logging.info('this build will be configured for exporting')
+        new_modules = settings.getProperty('build', 'vendor_modules_directory') or 'modules'
+        new_targets = settings.getProperty('build', 'vendor_targets_directory') or 'targets'
+        new_build_modules = settings.getProperty('build', 'built_modules_directory') or 'modules'
+        # to save downloading the cached files, copy the old cache
+        try:
+            if not os.path.exists(new_modules):
+                shutil.copytree(paths.Modules_Folder, new_modules)
+                shutil.copytree(paths.Targets_Folder, new_targets)
+        except Exception as e:
+            logging.error(e)
+            logging.error('failed to use existing cache; rebuilding')
+
+        paths.Modules_Folder = new_modules
+        paths.Targets_Folder = new_targets
+        paths.BUILT_MODULES_DIR = new_build_modules
+
+    args_dict.setdefault('build_targets', [])
 
     if 'test' in args.build_targets:
         logging.error('Cannot build "test". Use "yotta test" to run tests.')
         return {'status':1}
 
-    cwd = os.getcwd()
     c = validate.currentDirectoryModule()
     if not c:
         return {'status':1}
@@ -83,26 +115,27 @@ def installAndBuild(args, following_args):
 
     # run the install command before building, we need to add some options the
     # install command expects to be present to do this:
-    vars(args)['component'] = None
-    vars(args)['act_globally'] = False
+    args_dict['component'] = None
+    args_dict['act_globally'] = False
     if not hasattr(args, 'install_test_deps'):
         if 'all_tests' in args.build_targets:
-            vars(args)['install_test_deps'] = 'all'
+            args_dict['install_test_deps'] = 'all'
         elif not len(args.build_targets):
-            vars(args)['install_test_deps'] = 'own'
+            args_dict['install_test_deps'] = 'own'
         else:
             # If the named build targets include tests from other modules, we
             # need to install the deps for those modules. To do this we need to
             # be able to tell which module a library belongs to, which is not
             # straightforward (especially if there is custom cmake involved).
             # That's why this is 'all', and not 'none'.
-            vars(args)['install_test_deps'] = 'all'
+            args_dict['install_test_deps'] = 'all'
 
     # install may exit non-zero for non-fatal errors (such as incompatible
     # version specs), which it will display
     install_status = install.execCommand(args, [])
 
-    builddir = os.path.join(cwd, 'build', target.getName())
+    builddir = os.path.join(os.getcwd(), paths.DEFAULT_BUILD_DIR, target.getName()) if not export_mode_or_path else \
+        os.path.join(os.getcwd(), paths.DEFAULT_EXPORT_BUILD_RELPATH)
 
     all_deps = c.getDependenciesRecursive(
                       target = target,
@@ -126,7 +159,7 @@ def installAndBuild(args, following_args):
     logging.debug("config done, merged config: %s", config['merged_config_json'])
 
     script_environment = {
-        'YOTTA_MERGED_CONFIG_FILE': config['merged_config_json']
+        'YOTTA_MERGED_CONFIG_FILE': str(config['merged_config_json'])
     }
     # run pre-generate scripts for all components:
     runScriptWithModules(c, all_deps.values(), 'preGenerate', script_environment)
@@ -140,7 +173,42 @@ def installAndBuild(args, following_args):
     # run pre-build scripts for all components:
     runScriptWithModules(c, all_deps.values(), 'preBuild', script_environment)
 
-    if (not hasattr(args, 'generate_only')) or (not args.generate_only):
+    if export_mode_or_path and export_mode_or_path is not True:
+        # includes relative to cwd / project top level
+        includes = {
+            'source',
+            paths.DEFAULT_EXPORT_BUILD_RELPATH,
+            paths.Modules_Folder,
+            paths.Targets_Folder,
+            'yotta-cloud-client',  # not sure about whitelisting... where is this coming from?
+        }
+
+        def ignore_on_copy(current_dir, local_paths):
+            # only at the project root
+            if current_dir == '.':
+                # exclude = !include
+                return [p for p in local_paths if p not in includes]
+            return []
+        export_to = os.path.abspath(export_mode_or_path)
+        logging.info('exporting unbuilt project source and dependencies to %s', export_to)
+        check = os.path.join(export_to, 'source')  # this might be insufficient, or indeed misleading.
+        if os.path.exists(export_to) and os.listdir(export_to) and not os.path.exists(check):
+            # as the export can be any path we do a sanity check before calling 'rmRf'
+            raise Exception(
+                'Aborting export: directory is not empty and does not look like a previous export'
+                ' (expecting: %s)'
+                % (check)
+            )
+        fsutils.rmRf(export_to)
+        shutil.copytree(src='.', dst=export_to, ignore=ignore_on_copy)
+        fsutils.rmRf(builddir)
+        fsutils.rmRf(paths.Modules_Folder)
+        fsutils.rmRf(paths.Targets_Folder)
+
+    if args_dict.get('generate_only'):
+        logging.info('skipping build step')
+    else:
+        # build in the current directory
         error = target.build(
                 builddir, c, args, release_build=args.release_build,
                 build_args=following_args, targets=args.build_targets,

yotta/clean.py

@@ -21,4 +21,3 @@ def execCommand(args, following_args):
         return 1
 
     fsutils.rmRf(os.path.join(c.path, 'build'))
-

yotta/debug.py

@@ -9,6 +9,9 @@
 
 # validate, , validate things, internal
 from yotta.lib import validate
+# settings, , load and save settings, internal
+# paths
+from yotta.lib import paths
 # --config option, , , internal
 from yotta import options
 
@@ -33,7 +36,7 @@ def execCommand(args, following_args):
             logging.error(error)
         return 1
 
-    builddir = os.path.join(cwd, 'build', target.getName())
+    builddir = os.path.join(os.getcwd(), paths.DEFAULT_BUILD_DIR, target.getName())
 
     if args.program is None:
         if c.isApplication():

yotta/init.py

@@ -11,6 +11,7 @@
 
 # Component, , represents an installed component, internal
 from yotta.lib import component
+from yotta.lib import paths
 # version, , represent versions and specifications, internal
 from yotta.lib import version
 # validate, , validate various things, internal
@@ -67,7 +68,7 @@ def yesNo(string):
 yesNo.__allowed_message = ' Please reply "Yes", or "No".'
 
 def isBannedName(name):
-    return name in ('test', 'source', 'include', 'yotta_modules', 'yotta_targets')
+    return name in ('test', 'source', 'include', paths.Modules_Folder, paths.Targets_Folder)
 
 def notBannedName(s):
     if isBannedName(s):