ldcheck: comparison ldcheck.py

-:a3536e51f6bc
+:3555679d276b
 #!/usr/bin/env python3
-from sys import version_info
+import sys
-if version_info < (3, 4):
+if sys.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
+def check_library_paths(library_paths):
-script_directory = Path(realpath(__file__)).parent
+for library_path in library_paths:
-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
+raise RuntimeError(str.format(
-print(str.format(
+'error: library path {} does not exist',
-'Library path {} does not exist',
 library_path,
 ))
 elif not library_path.exists():
-problems = True
+raise RuntimeError(str.format(
-print(str.format(
+'error: library path {} is not a directory',
-'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):
+def find_ldconfig_ldr_paths(libraries):
-for library_path in library_paths(config):
+for library_path in libraries:
 yield from [
 library_path / path
 for path in ['LDConfig.ldr', 'ldconfig.ldr']
 if (library_path / path).is_file()
 ]
-import argparse
+def load_ldconfig(libraries):
+ldconfig_ldr_paths = list(find_ldconfig_ldr_paths(libraries))
+if not ldconfig_ldr_paths:
+raise RuntimeError('could not find any LDConfig.ldr')
+for ldconfig_ldr_path in ldconfig_ldr_paths:
+with ldconfig_ldr_path.open() as ldconfig_ldr:
+load_colours(ldconfig_ldr)
-class ListProblemsAction(argparse.Action):
+def parse_commandline_arguments():
-def __init__(self, option_strings, dest, nargs = None, **kwargs):
+import os
-super().__init__(option_strings, dest, nargs = 0, **kwargs)
+rcpath = Path(os.path.expanduser('~/.config/ldcheckrc'))
-def __call__(self, *args, **kwargs):
+if rcpath.exists():
-import testsuite
+with rcpath.open() as file:
-from sys import exit
+rcargs = ['--' + line.strip() for line in file]
-from re import sub
+else:
-test_suite = testsuite.load_tests()
+rcargs = []
-for warning_type in testsuite.all_problem_types(test_suite):
+import argparse
-print(str.format('{name}: {severity}: "{message}"',
+class ListProblemTypesAction(argparse.Action):
-name = warning_type.name,
+def __init__(self, option_strings, dest, nargs = None, **kwargs):
-severity = warning_type.severity,
+super().__init__(option_strings, dest, nargs = 0, **kwargs)
-message = warning_type.placeholder_message(),
+def __call__(self, *args, **kwargs):
-))
+import testsuite
-exit(0)
+test_suite = testsuite.load_tests()
+for warning_type in testsuite.all_problem_types(test_suite):
-if __name__ == '__main__':
+print(str.format('{name}: {severity}: "{message}"',
-from sys import argv
+name = warning_type.name,
+severity = warning_type.severity,
+message = warning_type.placeholder_message(),
+))
+sys.exit(0)
 parser = argparse.ArgumentParser()
 parser.add_argument('filename')
 parser.add_argument('--list',
-action = ListProblemsAction,
+action = ListProblemTypesAction,
 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('--subfile',
 action = 'store_true',
 help = 'finds a subfile by name and prints out information about it'
 )
-args = parser.parse_args()
+parser.add_argument('-l', '--library', action = 'append')
-config = load_config('ldcheck.cfg')
+arglist = rcargs + sys.argv[1:]
-for ldconfig_ldr_path in find_ldconfig_ldr_paths(config):
+return parser.parse_args(arglist)
-with ldconfig_ldr_path.open() as ldconfig_ldr:
-load_colours(ldconfig_ldr)
+def main():
+args = parse_commandline_arguments()
+# Make sure that we have at least one library path specified.
+if not args.library:
+raise RuntimeError(
+'Please specify libraries using the -l / --library switch.\n'
+'For example: -l ~/ldraw or --library=~/ldraw\n'
+'Multiple --library switches may be used.')
+# Prepare the list of libraries. This also expands the ~ for the home
+# directory
+import os
+libraries = [Path(os.path.expanduser(library)) for library in args.library]
+check_library_paths(libraries)
+load_ldconfig(libraries)
 if args.subfile:
+# Subfile debug mode: searches for the specified subfile from the LDraw
+# libraries, opens it as if it was referenced by something and prints
+# out all information that is calculated from this subfile.
 import filecache
-cache = filecache.SubfileCache(
+cache = filecache.SubfileCache(ldraw_directories = libraries)
-ldraw_directories = config['libraries'],
-)
 subfile = cache.prepare_file(args.filename)
 if not subfile.valid:
 print(subfile.problem)
 else:
 print('Flat dimensions:', repr(subfile.flatness))
 with open(args.filename, 'rb') as file:
 from os.path import basename
 model = parse.read_ldraw(
 file,
 name = basename(args.filename),
-ldraw_directories = config['libraries'])
+ldraw_directories = libraries)
 if args.dump:
+# Dump mode: prints out the structure of the processed LDraw file
 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:
+# Mark where the header is considered to end
 print('--------- End of header')
 print(entry)
 elif args.rebuild:
+# Debug rebuild mode: open the file, parse it and turn it back
+# into LDraw code and write it into stdout. This is used to ensure
+# that LDCheck does not miss any information while parsing files.
 for entry in model.body:
 print(entry.textual_representation(), end = '\r\n')
 else:
+# Regular mode
 from testsuite import load_tests, check_model, format_report
+# load the test suite
+# TODO: maybe add some command line argument to filter tests
+# in case the user wants to run some specific tests only or
+# possibly leave some test out
 test_suite = load_tests()
+# use the test suite to check the model
 report = check_model(model, test_suite)
+# print out the report
 print(format_report(report, model, test_suite))
+if __name__ == '__main__':
+try:
+main()
+except RuntimeError as e:
+import sys
+print('error:', str(e), file = sys.stderr)
+sys.exit(1)

Mercurial > ldcheck / file comparison

comparison: ldcheck.py

ldcheck.py