ldcheck.py

#!/usr/bin/env python3
from sys import version_info
if version_info < (3, 4):
    raise RuntimeError('Python 3.4 or newer required')

from colours import load_colours
from geometry import *
from pathlib import Path
import linetypes
import header
import parse

from os.path import realpath
script_directory = Path(realpath(__file__)).parent

def load_config(filename):
    from configobj import ConfigObj
    from copy import deepcopy
    config = ConfigObj(filename, encoding = 'UTF8')
    read_config = deepcopy(config)
    if 'libraries' not in config:
        config['libraries'] = ['/path/to/ldraw']
    if config != read_config:
        config.write()
    check_library_paths(config)
    return config

def library_paths(config):
    for library_path_string in config['libraries']:
        yield Path(library_path_string).expanduser()

def check_library_paths(config):
    from sys import exit
    problems = False
    have_paths = False
    for library_path in library_paths(config):
        have_paths = True
        if not library_path.exists():
            problems = True
            print(str.format(
                'Library path {} does not exist',
                library_path,
            ))
        elif not library_path.exists():
            problems = True
            print(str.format(
                'Library path {} is not a directory',
                library_path,
            ))
    if not have_paths:
        print('No LDraw path specified')
        problems = True
    if problems:
        print('Please fix ldcheck.cfg')
        exit(1)

def find_ldconfig_ldr_paths(config):
    for library_path in library_paths(config):
        yield from [
            library_path / path
            for path in ['LDConfig.ldr', 'ldconfig.ldr']
            if (library_path / path).is_file()
        ]

import argparse

class ListProblemsAction(argparse.Action):
    def __init__(self, option_strings, dest, nargs = None, **kwargs):
        super().__init__(option_strings, dest, nargs = 0, **kwargs)
    def __call__(self, *args, **kwargs):
        import testsuite
        from sys import exit
        from re import sub
        test_suite = testsuite.load_tests()
        for warning_type in testsuite.all_problem_types(test_suite):
            print(str.format('{name}: {severity}: "{message}"',
                name = warning_type.name,
                severity = warning_type.severity,
                message = warning_type.placeholder_message(),
            ))
        exit(0)

if __name__ == '__main__':
    from sys import argv
    parser = argparse.ArgumentParser()
    parser.add_argument('filename')
    parser.add_argument('--list',
        action = ListProblemsAction,
        help = 'lists all possible problem types and exit',
    )
    parser.add_argument('--dump',
        action = 'store_true',
        help = 'dumps the internal parsed structure of the part file',
    )
    parser.add_argument('--rebuild',
        action = 'store_true',
        help = 'parses the part file and prints it back out, used for '
            'testing whether the program interprets part files correctly',
    )
    parser.add_argument('--flatness',
        action = 'store_true',
        help = 'finds a primitive by name and prints out in which '
            'dimensions it is flat in',
    )
    args = parser.parse_args()
    config = load_config('ldcheck.cfg')
    for ldconfig_ldr_path in find_ldconfig_ldr_paths(config):
        with ldconfig_ldr_path.open() as ldconfig_ldr:
            load_colours(ldconfig_ldr)
    if args.flatness:
        import filecache
        cache = filecache.SubfileCache(
            ldraw_directories = config['libraries'],
        )
        subfile = cache.prepare_file(args.filename)
        if not subfile.valid:
            print(subfile.problem)
        else:
            if subfile.flatness:
                print(str.format(
                    'Flatness: {}',
                    ', '.join(subfile.flatness),
                ))
            else:
                print('File is not flat in any dimensions')
    else:
        with open(args.filename) as file:
            from os.path import basename
            model = parse.read_ldraw(
                file,
                name = basename(args.filename),
                ldraw_directories = config['libraries'])
            if args.dump:
                print('header: ' + type(model.header).__name__)
                for key in sorted(dir(model.header)):
                    if not key.startswith('__'):
                        print('\t' + key + ': ' + repr(getattr(model.header, key)))
                for i, entry in enumerate(model.body):
                    if model.header.valid and i == model.header_size:
                        print('--------- End of header')
                    print(entry)
            elif args.rebuild:
                for entry in model.body:
                    print(entry.textual_representation(), end = '\r\n')
            else:
                from testsuite import load_tests, check_model, format_report
                test_suite = load_tests()
                report = check_model(model, test_suite)
                print(format_report(report, model, test_suite))