init

cmake/external/glib/cppgir/expected-lite/script/create-cov-rpt.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+#
+# Copyright 2019-2019 by Martin Moene
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# script/create-cov-rpt.py, Python 3.4 and later
+#
+
+import argparse
+import os
+import re
+import sys
+import subprocess
+
+# Configuration:
+
+cfg_github_project   = 'expected-lite'
+cfg_github_user      = 'martinmoene'
+cfg_prj_folder_level = 3
+
+tpl_coverage_cmd     = 'opencppcoverage --no_aggregate_by_file --sources {src} -- {exe}'
+
+# End configuration.
+
+def project_folder( f, args ):
+    """Project root"""
+    if args.prj_folder:
+        return args.prj_folder
+    return os.path.normpath( os.path.join( os.path.dirname( os.path.abspath(f) ), '../' * args.prj_folder_level ) ) 
+
+def executable_folder( f ):
+    """Folder where the xecutable is"""
+    return  os.path.dirname( os.path.abspath(f) )
+
+def executable_name( f ):
+    """Folder where the executable is"""
+    return  os.path.basename( f )
+
+def createCoverageReport( f, args ):
+    print( "Creating coverage report for project '{usr}/{prj}', '{file}':".
+        format( usr=args.user, prj=args.project, file=f ) )
+    cmd = tpl_coverage_cmd.format( folder=executable_folder(f), src=project_folder(f, args), exe=executable_name(f) )
+    if args.verbose:
+        print( "> {}".format(cmd) )
+    if not args.dry_run:
+        os.chdir( executable_folder(f) )
+        subprocess.call( cmd, shell=False )
+        os.chdir( project_folder(f, args) )
+
+def createCoverageReports( args ):
+    for f in args.executable:
+        createCoverageReport( f, args )
+
+def createCoverageReportFromCommandLine():
+    """Collect arguments from the commandline and create coverage report."""
+    parser = argparse.ArgumentParser(
+        description='Create coverage report.',
+        epilog="""""",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument(
+        'executable',
+        metavar='executable',
+        type=str,
+        nargs=1,
+        help='executable to report on')
+
+    parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='do not execute conan commands')
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='count',
+        default=0,
+        help='level of progress reporting')
+
+    parser.add_argument(
+        '--user',
+        metavar='u',
+        type=str,
+        default=cfg_github_user,
+        help='github user name')
+
+    parser.add_argument(
+        '--project',
+        metavar='p',
+        type=str,
+        default=cfg_github_project,
+        help='github project name')
+
+    parser.add_argument(
+        '--prj-folder',
+        metavar='f',
+        type=str,
+        default=None,
+        help='project root folder')
+
+    parser.add_argument(
+        '--prj-folder-level',
+        metavar='n',
+        type=int,
+        default=cfg_prj_folder_level,
+        help='project root folder level from executable')
+
+    createCoverageReports( parser.parse_args() )
+
+if __name__ == '__main__':
+    createCoverageReportFromCommandLine()
+
+# end of file

cmake/external/glib/cppgir/expected-lite/script/create-vcpkg.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python
+#
+# Copyright 2019-2019 by Martin Moene
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# script/upload-conan.py, Python 3.4 and later
+#
+
+import argparse
+import os
+import re
+import sys
+import subprocess
+
+# Configuration:
+
+cfg_github_project = 'expected-lite'
+cfg_github_user    = 'martinmoene'
+cfg_description    = '(unused)'
+
+cfg_cmakelists     = 'CMakeLists.txt'
+cfg_readme         = 'Readme.md'
+cfg_license        = 'LICENSE.txt'
+cfg_ref_prefix     = 'v'
+
+cfg_sha512            = 'dadeda'
+cfg_vcpkg_description = '(no description found)'
+cfg_vcpkg_root        = os.environ['VCPKG_ROOT']
+
+cfg_cmake_optpfx      = "EXPECTED_LITE"
+
+# End configuration.
+
+# vcpkg  control and port templates:
+
+tpl_path_vcpkg_control  = '{vcpkg}/ports/{prj}/CONTROL'
+tpl_path_vcpkg_portfile = '{vcpkg}/ports/{prj}/portfile.cmake'
+
+tpl_vcpkg_control =\
+"""Source: {prj}
+Version: {ver}
+Description: {desc}"""
+
+tpl_vcpkg_portfile =\
+"""include(vcpkg_common_functions)
+
+vcpkg_from_github(
+    OUT_SOURCE_PATH SOURCE_PATH
+    REPO {usr}/{prj}
+    REF {ref}
+    SHA512 {sha}
+)
+
+vcpkg_configure_cmake(
+    SOURCE_PATH ${{SOURCE_PATH}}
+    PREFER_NINJA
+    OPTIONS
+        -D{optpfx}_OPT_BUILD_TESTS=OFF
+        -D{optpfx}_OPT_BUILD_EXAMPLES=OFF
+)
+
+vcpkg_install_cmake()
+
+vcpkg_fixup_cmake_targets(
+    CONFIG_PATH lib/cmake/${{PORT}}
+)
+
+file(REMOVE_RECURSE
+    ${{CURRENT_PACKAGES_DIR}}/debug
+    ${{CURRENT_PACKAGES_DIR}}/lib
+)
+
+file(INSTALL
+    ${{SOURCE_PATH}}/{lic} DESTINATION ${{CURRENT_PACKAGES_DIR}}/share/${{PORT}} RENAME copyright
+)"""
+
+tpl_vcpkg_note_sha =\
+"""
+Next actions:
+- Obtain package SHA: 'vcpkg install {prj}', copy SHA mentioned in 'Actual hash: [...]'
+- Add SHA to package: 'script\create-vcpkg --sha={sha}'
+- Install package   : 'vcpkg install {prj}'"""
+
+tpl_vcpkg_note_install =\
+"""
+Next actions:
+- Install package: 'vcpkg install {prj}'"""
+
+# End of vcpkg templates
+
+def versionFrom( filename ):
+    """Obtain version from CMakeLists.txt"""
+    with open( filename, 'r' ) as f:
+        content = f.read()
+        version = re.search(r'VERSION\s(\d+\.\d+\.\d+)', content).group(1)
+    return version
+
+def descriptionFrom( filename ):
+    """Obtain description from CMakeLists.txt"""
+    with open( filename, 'r' ) as f:
+        content = f.read()
+        description = re.search(r'DESCRIPTION\s"(.*)"', content).group(1)
+    return description if description else cfg_vcpkg_description
+
+def vcpkgRootFrom( path ):
+    return path if path else './vcpkg'
+
+def to_ref( version ):
+    """Add prefix to version/tag, like v1.2.3"""
+    return cfg_ref_prefix + version
+
+def control_path( args ):
+    """Create path like vcpks/ports/_project_/CONTROL"""
+    return tpl_path_vcpkg_control.format( vcpkg=args.vcpkg_root, prj=args.project )
+
+def portfile_path( args ):
+    """Create path like vcpks/ports/_project_/portfile.cmake"""
+    return tpl_path_vcpkg_portfile.format( vcpkg=args.vcpkg_root, prj=args.project )
+
+def createControl( args ):
+    """Create vcpkg CONTROL file"""
+    output = tpl_vcpkg_control.format(
+        prj=args.project, ver=args.version, desc=args.description )
+    if args.verbose:
+        print( "Creating control file '{f}':".format( f=control_path( args ) ) )
+    if args.verbose > 1:
+         print( output )
+    os.makedirs( os.path.dirname( control_path( args ) ), exist_ok=True )
+    with open( control_path( args ), 'w') as f:
+        print( output, file=f )
+
+def createPortfile( args ):
+    """Create vcpkg portfile"""
+    output = tpl_vcpkg_portfile.format(
+        optpfx=cfg_cmake_optpfx, usr=args.user, prj=args.project, ref=to_ref(args.version), sha=args.sha, lic=cfg_license )
+    if args.verbose:
+        print( "Creating portfile '{f}':".format( f=portfile_path( args ) ) )
+    if args.verbose > 1:
+        print( output )
+    os.makedirs( os.path.dirname( portfile_path( args ) ), exist_ok=True )
+    with open( portfile_path( args ), 'w') as f:
+        print( output, file=f )
+
+def printNotes( args ):
+    if args.sha == cfg_sha512:
+        print( tpl_vcpkg_note_sha.
+            format( prj=args.project, sha='...' ) )
+    else:
+        print( tpl_vcpkg_note_install.
+            format( prj=args.project ) )
+
+def createVcpkg( args ):
+    print( "Creating vcpkg for '{usr}/{prj}', version '{ver}' in folder '{vcpkg}':".
+        format( usr=args.user, prj=args.project, ver=args.version, vcpkg=args.vcpkg_root, ) )
+    createControl( args )
+    createPortfile( args )
+    printNotes( args )
+
+def createVcpkgFromCommandLine():
+    """Collect arguments from the commandline and create vcpkg."""
+
+    parser = argparse.ArgumentParser(
+        description='Create microsoft vcpkg.',
+        epilog="""""",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='count',
+        default=0,
+        help='level of progress reporting')
+
+    parser.add_argument(
+        '--user',
+        metavar='u',
+        type=str,
+        default=cfg_github_user,
+        help='github user name')
+
+    parser.add_argument(
+        '--project',
+        metavar='p',
+        type=str,
+        default=cfg_github_project,
+        help='github project name')
+
+    parser.add_argument(
+        '--description',
+        metavar='d',
+        type=str,
+#       default=cfg_description,
+        default=descriptionFrom( cfg_cmakelists ),
+        help='vcpkg description [from ' + cfg_cmakelists + ']')
+
+    parser.add_argument(
+        '--version',
+        metavar='v',
+        type=str,
+        default=versionFrom( cfg_cmakelists ),
+        help='version number [from ' + cfg_cmakelists + ']')
+
+    parser.add_argument(
+        '--sha',
+        metavar='s',
+        type=str,
+        default=cfg_sha512,
+        help='sha of package')
+
+    parser.add_argument(
+        '--vcpkg-root',
+        metavar='r',
+        type=str,
+        default=vcpkgRootFrom( cfg_vcpkg_root ),
+        help='parent folder containing ports to write files to')
+
+    createVcpkg( parser.parse_args() )
+
+if __name__ == '__main__':
+    createVcpkgFromCommandLine()
+
+# end of file

cmake/external/glib/cppgir/expected-lite/script/update-version.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+#
+# Copyright 2017-2018 by Martin Moene
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# script/update-version.py
+#
+
+from __future__ import print_function
+
+import argparse
+import os
+import re
+import sys
+
+# Configuration:
+
+table = (
+    # path, substitute find, substitute format
+    ( 'CMakeLists.txt'
+        , r'\W{2,4}VERSION\W+([0-9]+\.[0-9]+\.[0-9]+)\W*$'
+        , '    VERSION {major}.{minor}.{patch}' )
+
+    , ( 'CMakeLists.txt'
+        , r'set\W+expected_lite_version\W+"([0-9]+\.[0-9]+\.[0-9]+)"\W+$'
+        , 'set( expected_lite_version "{major}.{minor}.{patch}" )\n' )
+
+#    , ( 'example/cmake-pkg/CMakeLists.txt'
+#        , r'set\W+expected_lite_version\W+"([0-9]+\.[0-9]+(\.[0-9]+)?)"\W+$'
+#        , 'set( expected_lite_version "{major}.{minor}" )\n' )
+#
+#    , ( 'script/install-xxx-pkg.py'
+#        , r'\expected_lite_version\s+=\s+"([0-9]+\.[0-9]+\.[0-9]+)"\s*$'
+#        , 'expected_lite_version = "{major}.{minor}.{patch}"\n' )
+
+    , ( 'conanfile.py'
+        , r'version\s+=\s+"([0-9]+\.[0-9]+\.[0-9]+)"\s*$'
+        , 'version = "{major}.{minor}.{patch}"' )
+
+    , ( 'include/nonstd/expected.hpp'
+        , r'\#define\s+expected_lite_MAJOR\s+[0-9]+\s*$'
+        , '#define expected_lite_MAJOR  {major}' )
+
+    , ( 'include/nonstd/expected.hpp'
+        , r'\#define\s+expected_lite_MINOR\s+[0-9]+\s*$'
+        , '#define expected_lite_MINOR  {minor}' )
+
+    , ( 'include/nonstd/expected.hpp'
+        , r'\#define\s+expected_lite_PATCH\s+[0-9]+\s*$'
+        , '#define expected_lite_PATCH  {patch}\n' )
+)
+
+# End configuration.
+
+def readFile( in_path ):
+    """Return content of file at given path"""
+    with open( in_path, 'r' ) as in_file:
+        contents = in_file.read()
+    return contents
+
+def writeFile( out_path, contents ):
+    """Write contents to file at given path"""
+    with open( out_path, 'w' ) as out_file:
+        out_file.write( contents )
+
+def replaceFile( output_path, input_path ):
+    # prevent race-condition (Python 3.3):
+    if sys.version_info >= (3, 3):
+        os.replace( output_path, input_path )
+    else:
+        os.remove( input_path )
+        os.rename( output_path, input_path )
+
+def editFileToVersion( version, info, verbose ):
+    """Update version given file path, version regexp and new version format in info"""
+    major, minor, patch = version.split('.')
+    in_path, ver_re, ver_fmt = info
+    out_path = in_path + '.tmp'
+    new_text = ver_fmt.format( major=major, minor=minor, patch=patch )
+
+    if verbose:
+        print( "- {path} => '{text}':".format( path=in_path, text=new_text.strip('\n') ) )
+
+    writeFile(
+        out_path,
+        re.sub(
+            ver_re, new_text, readFile( in_path )
+            , count=0, flags=re.MULTILINE
+        )
+    )
+    replaceFile( out_path, in_path )
+
+def editFilesToVersion( version, table, verbose ):
+    if verbose:
+        print( "Editing files to version {v}:".format(v=version) )
+    for item in table:
+        editFileToVersion( version, item, verbose )
+
+def editFilesToVersionFromCommandLine():
+    """Update version number given on command line in paths from configuration table."""
+
+    parser = argparse.ArgumentParser(
+        description='Update version number in files.',
+        epilog="""""",
+        formatter_class=argparse.RawTextHelpFormatter)
+
+    parser.add_argument(
+        'version',
+        metavar='version',
+        type=str,
+        nargs=1,
+        help='new version number, like 1.2.3')
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='report the name of the file being processed')
+
+    args = parser.parse_args()
+
+    editFilesToVersion( args.version[0], table, args.verbose )
+
+
+if __name__ == '__main__':
+    editFilesToVersionFromCommandLine()
+
+# end of file

cmake/external/glib/cppgir/expected-lite/script/upload-conan.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+#
+# Copyright 2019-2019 by Martin Moene
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# script/upload-conan.py
+#
+
+from __future__ import print_function
+
+import argparse
+import os
+import re
+import sys
+import subprocess
+
+# Configuration:
+
+def_conan_project = 'expected-lite'
+def_conan_user    = 'nonstd-lite'
+def_conan_channel = 'stable'
+cfg_conanfile     = 'conanfile.py'
+
+tpl_conan_create  = 'conan create . {usr}/{chn}'
+tpl_conan_upload  = 'conan upload --remote {usr} {prj}/{ver}@{usr}/{chn}'
+
+# End configuration.
+
+def versionFrom( filename ):
+    """Obtain version from  conanfile.py"""
+    with open( filename ) as f:
+        content = f.read()
+        version = re.search(r'version\s=\s"(.*)"', content).group(1)
+    return version
+
+def createConanPackage( args ):
+    """Create conan package and upload it."""
+    cmd = tpl_conan_create.format(usr=args.user, chn=args.channel)
+    if args.verbose:
+        print( "> {}".format(cmd) )
+    if not args.dry_run:
+        subprocess.call( cmd, shell=False )
+
+def uploadConanPackage( args ):
+    """Create conan package and upload it."""
+    cmd = tpl_conan_upload.format(prj=args.project, usr=args.user, chn=args.channel, ver=args.version)
+    if args.verbose:
+        print( "> {}".format(cmd) )
+    if not args.dry_run:
+        subprocess.call( cmd, shell=False )
+
+def uploadToConan( args ):
+    """Create conan package and upload it."""
+    print( "Updating project '{prj}' to user '{usr}', channel '{chn}', version {ver}:".
+        format(prj=args.project, usr=args.user, chn=args.channel, ver=args.version) )
+    createConanPackage( args )
+    uploadConanPackage( args )
+
+def uploadToConanFromCommandLine():
+    """Collect arguments from the commandline and create conan package and upload it."""
+
+    parser = argparse.ArgumentParser(
+        description='Create conan package and upload it to conan.',
+        epilog="""""",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='do not execute conan commands')
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='count',
+        default=0,
+        help='level of progress reporting')
+
+    parser.add_argument(
+        '--project',
+        metavar='p',
+        type=str,
+        default=def_conan_project,
+        help='conan project')
+
+    parser.add_argument(
+        '--user',
+        metavar='u',
+        type=str,
+        default=def_conan_user,
+        help='conan user')
+
+    parser.add_argument(
+        '--channel',
+        metavar='c',
+        type=str,
+        default=def_conan_channel,
+        help='conan channel')
+
+    parser.add_argument(
+        '--version',
+        metavar='v',
+        type=str,
+        default=versionFrom( cfg_conanfile ),
+        help='version number [from conanfile.py]')
+
+    uploadToConan( parser.parse_args() )
+
+
+if __name__ == '__main__':
+    uploadToConanFromCommandLine()
+
+# end of file