diff options
Diffstat (limited to 'lib')
| m--------- | lib/chibios | 0 | ||||
| m--------- | lib/chibios-contrib | 0 | ||||
| -rw-r--r-- | lib/python/qmk/c_parse.py | 26 | ||||
| -rw-r--r-- | lib/python/qmk/cli/__init__.py | 23 | ||||
| -rw-r--r-- | lib/python/qmk/cli/c2json.py | 3 | ||||
| -rw-r--r-- | lib/python/qmk/cli/chibios/confmigrate.py | 9 | ||||
| -rw-r--r-- | lib/python/qmk/cli/generate/__init__.py | 4 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/generate/api.py | 14 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/generate/config_h.py | 152 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/generate/info_json.py | 65 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/generate/layouts.py | 98 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/generate/rules_mk.py | 91 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/info.py | 7 | ||||
| -rw-r--r-- | lib/python/qmk/cli/json/__init__.py | 5 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/json/keymap.py | 16 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/kle2json.py | 51 | ||||
| -rw-r--r-- | lib/python/qmk/constants.py | 15 | ||||
| -rw-r--r-- | lib/python/qmk/info.py | 457 | ||||
| -rwxr-xr-x | lib/python/qmk/info_json_encoder.py | 96 | ||||
| -rw-r--r-- | lib/python/qmk/os_helpers/linux/__init__.py | 1 | ||||
| -rw-r--r-- | lib/python/qmk/tests/test_cli_commands.py | 29 | 
21 files changed, 998 insertions, 164 deletions
| diff --git a/lib/chibios b/lib/chibios -Subproject 313416b8fda90d9973a749a0a35970956852c28 +Subproject ffe54d63cb10a355add318f8e922e39f1c3d4bf diff --git a/lib/chibios-contrib b/lib/chibios-contrib -Subproject e3a3a24047717af33b098266e11c2e4e5102206 +Subproject 61baa6b036138c155f7cfc5646d833d9423f324 diff --git a/lib/python/qmk/c_parse.py b/lib/python/qmk/c_parse.py index e41e271a43..ade3e38059 100644 --- a/lib/python/qmk/c_parse.py +++ b/lib/python/qmk/c_parse.py @@ -1,12 +1,27 @@  """Functions for working with config.h files.  """  from pathlib import Path +import re  from milc import cli  from qmk.comment_remover import comment_remover  default_key_entry = {'x': -1, 'y': 0, 'w': 1} +single_comment_regex = re.compile(r' */[/*].*$') +multi_comment_regex = re.compile(r'/\*(.|\n)*?\*/', re.MULTILINE) + + +def strip_line_comment(string): +    """Removes comments from a single line string. +    """ +    return single_comment_regex.sub('', string) + + +def strip_multiline_comment(string): +    """Removes comments from a single line string. +    """ +    return multi_comment_regex.sub('', string)  def c_source_files(dir_names): @@ -53,7 +68,8 @@ def find_layouts(file):              parsed_layout = [_default_key(key) for key in layout.split(',')]              for key in parsed_layout: -                key['matrix'] = matrix_locations.get(key['label']) +                if key['label'] in matrix_locations: +                    key['matrix'] = matrix_locations[key['label']]              parsed_layouts[macro_name] = {                  'key_count': len(parsed_layout), @@ -88,12 +104,10 @@ def parse_config_h_file(config_h_file, config_h=None):      if config_h_file.exists():          config_h_text = config_h_file.read_text()          config_h_text = config_h_text.replace('\\\n', '') +        config_h_text = strip_multiline_comment(config_h_text)          for linenum, line in enumerate(config_h_text.split('\n')): -            line = line.strip() - -            if '//' in line: -                line = line[:line.index('//')].strip() +            line = strip_line_comment(line).strip()              if not line:                  continue @@ -156,6 +170,6 @@ def _parse_matrix_locations(matrix, file, macro_name):          row = row.replace('{', '').replace('}', '')          for col_num, identifier in enumerate(row.split(',')):              if identifier != 'KC_NO': -                matrix_locations[identifier] = (row_num, col_num) +                matrix_locations[identifier] = [row_num, col_num]      return matrix_locations diff --git a/lib/python/qmk/cli/__init__.py b/lib/python/qmk/cli/__init__.py index 372c40921a..a5f1f47679 100644 --- a/lib/python/qmk/cli/__init__.py +++ b/lib/python/qmk/cli/__init__.py @@ -19,7 +19,6 @@ from . import flash  from . import generate  from . import hello  from . import info -from . import json  from . import json2c  from . import lint  from . import list @@ -28,6 +27,24 @@ from . import new  from . import pyformat  from . import pytest -if sys.version_info[0] != 3 or sys.version_info[1] < 6: -    cli.log.error('Your Python is too old! Please upgrade to Python 3.6 or later.') +# Supported version information +# +# Based on the OSes we support these are the minimum python version available by default. +# Last update: 2021 Jan 02 +# +# Arch: 3.9 +# Debian: 3.7 +# Fedora 31: 3.7 +# Fedora 32: 3.8 +# Fedora 33: 3.9 +# FreeBSD: 3.7 +# Gentoo: 3.7 +# macOS: 3.9 (from homebrew) +# msys2: 3.8 +# Slackware: 3.7 +# solus: 3.7 +# void: 3.9 + +if sys.version_info[0] != 3 or sys.version_info[1] < 7: +    cli.log.error('Your Python is too old! Please upgrade to Python 3.7 or later.')      exit(127) diff --git a/lib/python/qmk/cli/c2json.py b/lib/python/qmk/cli/c2json.py index 2b3bb774f7..8f9d8dc383 100644 --- a/lib/python/qmk/cli/c2json.py +++ b/lib/python/qmk/cli/c2json.py @@ -6,6 +6,7 @@ from milc import cli  import qmk.keymap  import qmk.path +from qmk.info_json_encoder import InfoJSONEncoder  @cli.argument('--no-cpp', arg_only=True, action='store_false', help='Do not use \'cpp\' on keymap.c') @@ -47,7 +48,7 @@ def c2json(cli):          cli.args.output.parent.mkdir(parents=True, exist_ok=True)          if cli.args.output.exists():              cli.args.output.replace(cli.args.output.name + '.bak') -        cli.args.output.write_text(json.dumps(keymap_json)) +        cli.args.output.write_text(json.dumps(keymap_json, cls=InfoJSONEncoder))          if not cli.args.quiet:              cli.log.info('Wrote keymap to %s.', cli.args.output) diff --git a/lib/python/qmk/cli/chibios/confmigrate.py b/lib/python/qmk/cli/chibios/confmigrate.py index b9cfda9614..3e348b2b07 100644 --- a/lib/python/qmk/cli/chibios/confmigrate.py +++ b/lib/python/qmk/cli/chibios/confmigrate.py @@ -32,7 +32,7 @@ file_header = """\  /*   * This file was auto-generated by: - *    `qmk chibios-confupdate -i {0} -r {1}` + *    `qmk chibios-confmigrate -i {0} -r {1}`   */  #pragma once @@ -111,6 +111,7 @@ def migrate_mcuconf_h(to_override, outfile):  @cli.argument('-r', '--reference', type=normpath, arg_only=True, help='Specify the reference file to compare against')  @cli.argument('-o', '--overwrite', arg_only=True, action='store_true', help='Overwrites the input file during migration.')  @cli.argument('-d', '--delete', arg_only=True, action='store_true', help='If the file has no overrides, migration will delete the input file.') [email protected]('-f', '--force', arg_only=True, action='store_true', help='Re-migrates an already migrated file, even if it doesn\'t detect a full ChibiOS config.')  @cli.subcommand('Generates a migrated ChibiOS configuration file, as a result of comparing the input against a reference')  def chibios_confmigrate(cli):      """Generates a usable ChibiOS replacement configuration file, based on a fully-defined conf and a reference config. @@ -142,19 +143,19 @@ def chibios_confmigrate(cli):          eprint('--------------------------------------') -        if "CHCONF_H" in input_defs["dict"] or "_CHCONF_H_" in input_defs["dict"]: +        if cli.args.input.name == "chconf.h" and ("CHCONF_H" in input_defs["dict"] or "_CHCONF_H_" in input_defs["dict"] or cli.args.force):              migrate_chconf_h(to_override, outfile=sys.stdout)              if cli.args.overwrite:                  with open(cli.args.input, "w") as out_file:                      migrate_chconf_h(to_override, outfile=out_file) -        elif "HALCONF_H" in input_defs["dict"] or "_HALCONF_H_" in input_defs["dict"]: +        elif cli.args.input.name == "halconf.h" and ("HALCONF_H" in input_defs["dict"] or "_HALCONF_H_" in input_defs["dict"] or cli.args.force):              migrate_halconf_h(to_override, outfile=sys.stdout)              if cli.args.overwrite:                  with open(cli.args.input, "w") as out_file:                      migrate_halconf_h(to_override, outfile=out_file) -        elif "MCUCONF_H" in input_defs["dict"] or "_MCUCONF_H_" in input_defs["dict"]: +        elif cli.args.input.name == "mcuconf.h" and ("MCUCONF_H" in input_defs["dict"] or "_MCUCONF_H_" in input_defs["dict"] or cli.args.force):              migrate_mcuconf_h(to_override, outfile=sys.stdout)              if cli.args.overwrite:                  with open(cli.args.input, "w") as out_file: diff --git a/lib/python/qmk/cli/generate/__init__.py b/lib/python/qmk/cli/generate/__init__.py index f9585bfb5c..bd75b044c5 100644 --- a/lib/python/qmk/cli/generate/__init__.py +++ b/lib/python/qmk/cli/generate/__init__.py @@ -1,3 +1,7 @@  from . import api +from . import config_h  from . import docs +from . import info_json +from . import layouts  from . import rgb_breathe_table +from . import rules_mk diff --git a/lib/python/qmk/cli/generate/api.py b/lib/python/qmk/cli/generate/api.py index 66db37cb52..6d111f244c 100755 --- a/lib/python/qmk/cli/generate/api.py +++ b/lib/python/qmk/cli/generate/api.py @@ -8,6 +8,7 @@ from milc import cli  from qmk.datetime import current_datetime  from qmk.info import info_json +from qmk.info_json_encoder import InfoJSONEncoder  from qmk.keyboard import list_keyboards @@ -44,15 +45,16 @@ def generate_api(cli):          if 'usb' in kb_all['keyboards'][keyboard_name]:              usb = kb_all['keyboards'][keyboard_name]['usb'] -            if usb['vid'] not in usb_list['devices']: +            if 'vid' in usb and usb['vid'] not in usb_list['devices']:                  usb_list['devices'][usb['vid']] = {} -            if usb['pid'] not in usb_list['devices'][usb['vid']]: +            if 'pid' in usb and usb['pid'] not in usb_list['devices'][usb['vid']]:                  usb_list['devices'][usb['vid']][usb['pid']] = {} -            usb_list['devices'][usb['vid']][usb['pid']][keyboard_name] = usb +            if 'vid' in usb and 'pid' in usb: +                usb_list['devices'][usb['vid']][usb['pid']][keyboard_name] = usb      # Write the global JSON files -    keyboard_list.write_text(json.dumps({'last_updated': current_datetime(), 'keyboards': sorted(kb_all['keyboards'])})) -    keyboard_all.write_text(json.dumps(kb_all)) -    usb_file.write_text(json.dumps(usb_list)) +    keyboard_list.write_text(json.dumps({'last_updated': current_datetime(), 'keyboards': sorted(kb_all['keyboards'])}, cls=InfoJSONEncoder)) +    keyboard_all.write_text(json.dumps(kb_all, cls=InfoJSONEncoder)) +    usb_file.write_text(json.dumps(usb_list, cls=InfoJSONEncoder)) diff --git a/lib/python/qmk/cli/generate/config_h.py b/lib/python/qmk/cli/generate/config_h.py new file mode 100755 index 0000000000..7ddad745d1 --- /dev/null +++ b/lib/python/qmk/cli/generate/config_h.py @@ -0,0 +1,152 @@ +"""Used by the make system to generate info_config.h from info.json. +""" +from pathlib import Path + +from dotty_dict import dotty +from milc import cli + +from qmk.decorators import automagic_keyboard, automagic_keymap +from qmk.info import _json_load, info_json +from qmk.path import is_keyboard, normpath + + +def direct_pins(direct_pins): +    """Return the config.h lines that set the direct pins. +    """ +    rows = [] + +    for row in direct_pins: +        cols = ','.join(map(str, [col or 'NO_PIN' for col in row])) +        rows.append('{' + cols + '}') + +    col_count = len(direct_pins[0]) +    row_count = len(direct_pins) + +    return """ +#ifndef MATRIX_COLS +#   define MATRIX_COLS %s +#endif // MATRIX_COLS + +#ifndef MATRIX_ROWS +#   define MATRIX_ROWS %s +#endif // MATRIX_ROWS + +#ifndef DIRECT_PINS +#   define DIRECT_PINS {%s} +#endif // DIRECT_PINS +""" % (col_count, row_count, ','.join(rows)) + + +def pin_array(define, pins): +    """Return the config.h lines that set a pin array. +    """ +    pin_num = len(pins) +    pin_array = ', '.join(map(str, [pin or 'NO_PIN' for pin in pins])) + +    return f""" +#ifndef {define}S +#   define {define}S {pin_num} +#endif // {define}S + +#ifndef {define}_PINS +#   define {define}_PINS {{ {pin_array} }} +#endif // {define}_PINS +""" + + +def matrix_pins(matrix_pins): +    """Add the matrix config to the config.h. +    """ +    pins = [] + +    if 'direct' in matrix_pins: +        pins.append(direct_pins(matrix_pins['direct'])) + +    if 'cols' in matrix_pins: +        pins.append(pin_array('MATRIX_COL', matrix_pins['cols'])) + +    if 'rows' in matrix_pins: +        pins.append(pin_array('MATRIX_ROW', matrix_pins['rows'])) + +    return '\n'.join(pins) + + [email protected]('-o', '--output', arg_only=True, type=normpath, help='File to write to') [email protected]('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") [email protected]('-kb', '--keyboard', help='Keyboard to generate config.h for.') [email protected]('Used by the make system to generate info_config.h from info.json', hidden=True) +@automagic_keyboard +@automagic_keymap +def generate_config_h(cli): +    """Generates the info_config.h file. +    """ +    # Determine our keyboard(s) +    if not cli.config.generate_config_h.keyboard: +        cli.log.error('Missing paramater: --keyboard') +        cli.subcommands['info'].print_help() +        return False + +    if not is_keyboard(cli.config.generate_config_h.keyboard): +        cli.log.error('Invalid keyboard: "%s"', cli.config.generate_config_h.keyboard) +        return False + +    # Build the info_config.h file. +    kb_info_json = dotty(info_json(cli.config.generate_config_h.keyboard)) +    info_config_map = _json_load(Path('data/mappings/info_config.json')) + +    config_h_lines = ['/* This file was generated by `qmk generate-config-h`. Do not edit or copy.' ' */', '', '#pragma once'] + +    # Iterate through the info_config map to generate basic things +    for config_key, info_dict in info_config_map.items(): +        info_key = info_dict['info_key'] +        key_type = info_dict.get('value_type', 'str') +        to_config = info_dict.get('to_config', True) + +        if not to_config: +            continue + +        try: +            config_value = kb_info_json[info_key] +        except KeyError: +            continue + +        if key_type.startswith('array'): +            config_h_lines.append('') +            config_h_lines.append(f'#ifndef {config_key}') +            config_h_lines.append(f'#   define {config_key} {{ {", ".join(map(str, config_value))} }}') +            config_h_lines.append(f'#endif // {config_key}') +        elif key_type == 'bool': +            if config_value: +                config_h_lines.append('') +                config_h_lines.append(f'#ifndef {config_key}') +                config_h_lines.append(f'#   define {config_key}') +                config_h_lines.append(f'#endif // {config_key}') +        elif key_type == 'mapping': +            for key, value in config_value.items(): +                config_h_lines.append('') +                config_h_lines.append(f'#ifndef {key}') +                config_h_lines.append(f'#   define {key} {value}') +                config_h_lines.append(f'#endif // {key}') +        else: +            config_h_lines.append('') +            config_h_lines.append(f'#ifndef {config_key}') +            config_h_lines.append(f'#   define {config_key} {config_value}') +            config_h_lines.append(f'#endif // {config_key}') + +    if 'matrix_pins' in kb_info_json: +        config_h_lines.append(matrix_pins(kb_info_json['matrix_pins'])) + +    # Show the results +    config_h = '\n'.join(config_h_lines) + +    if cli.args.output: +        cli.args.output.parent.mkdir(parents=True, exist_ok=True) +        if cli.args.output.exists(): +            cli.args.output.replace(cli.args.output.name + '.bak') +        cli.args.output.write_text(config_h) + +        if not cli.args.quiet: +            cli.log.info('Wrote info_config.h to %s.', cli.args.output) + +    else: +        print(config_h) diff --git a/lib/python/qmk/cli/generate/info_json.py b/lib/python/qmk/cli/generate/info_json.py new file mode 100755 index 0000000000..f3fc54ddcf --- /dev/null +++ b/lib/python/qmk/cli/generate/info_json.py @@ -0,0 +1,65 @@ +"""Keyboard information script. + +Compile an info.json for a particular keyboard and pretty-print it. +""" +import json + +from jsonschema import Draft7Validator, validators +from milc import cli + +from qmk.decorators import automagic_keyboard, automagic_keymap +from qmk.info import info_json, _jsonschema +from qmk.info_json_encoder import InfoJSONEncoder +from qmk.path import is_keyboard + + +def pruning_validator(validator_class): +    """Extends Draft7Validator to remove properties that aren't specified in the schema. +    """ +    validate_properties = validator_class.VALIDATORS["properties"] + +    def remove_additional_properties(validator, properties, instance, schema): +        for prop in list(instance.keys()): +            if prop not in properties: +                del instance[prop] + +        for error in validate_properties(validator, properties, instance, schema): +            yield error + +    return validators.extend(validator_class, {"properties": remove_additional_properties}) + + +def strip_info_json(kb_info_json): +    """Remove the API-only properties from the info.json. +    """ +    pruning_draft_7_validator = pruning_validator(Draft7Validator) +    schema = _jsonschema('keyboard') +    validator = pruning_draft_7_validator(schema).validate + +    return validator(kb_info_json) + + [email protected]('-kb', '--keyboard', help='Keyboard to show info for.') [email protected]('-km', '--keymap', help='Show the layers for a JSON keymap too.') [email protected]('Generate an info.json file for a keyboard.', hidden=False if cli.config.user.developer else True) +@automagic_keyboard +@automagic_keymap +def generate_info_json(cli): +    """Generate an info.json file for a keyboard +    """ +    # Determine our keyboard(s) +    if not cli.config.generate_info_json.keyboard: +        cli.log.error('Missing parameter: --keyboard') +        cli.subcommands['info'].print_help() +        return False + +    if not is_keyboard(cli.config.generate_info_json.keyboard): +        cli.log.error('Invalid keyboard: "%s"', cli.config.generate_info_json.keyboard) +        return False + +    # Build the info.json file +    kb_info_json = info_json(cli.config.generate_info_json.keyboard) +    strip_info_json(kb_info_json) + +    # Display the results +    print(json.dumps(kb_info_json, indent=2, cls=InfoJSONEncoder)) diff --git a/lib/python/qmk/cli/generate/layouts.py b/lib/python/qmk/cli/generate/layouts.py new file mode 100755 index 0000000000..b7baae0651 --- /dev/null +++ b/lib/python/qmk/cli/generate/layouts.py @@ -0,0 +1,98 @@ +"""Used by the make system to generate layouts.h from info.json. +""" +from milc import cli + +from qmk.constants import COL_LETTERS, ROW_LETTERS +from qmk.decorators import automagic_keyboard, automagic_keymap +from qmk.info import info_json +from qmk.path import is_keyboard, normpath + +usb_properties = { +    'vid': 'VENDOR_ID', +    'pid': 'PRODUCT_ID', +    'device_ver': 'DEVICE_VER', +} + + [email protected]('-o', '--output', arg_only=True, type=normpath, help='File to write to') [email protected]('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") [email protected]('-kb', '--keyboard', help='Keyboard to generate config.h for.') [email protected]('Used by the make system to generate layouts.h from info.json', hidden=True) +@automagic_keyboard +@automagic_keymap +def generate_layouts(cli): +    """Generates the layouts.h file. +    """ +    # Determine our keyboard(s) +    if not cli.config.generate_layouts.keyboard: +        cli.log.error('Missing paramater: --keyboard') +        cli.subcommands['info'].print_help() +        return False + +    if not is_keyboard(cli.config.generate_layouts.keyboard): +        cli.log.error('Invalid keyboard: "%s"', cli.config.generate_layouts.keyboard) +        return False + +    # Build the info.json file +    kb_info_json = info_json(cli.config.generate_layouts.keyboard) + +    # Build the layouts.h file. +    layouts_h_lines = ['/* This file was generated by `qmk generate-layouts`. Do not edit or copy.' ' */', '', '#pragma once'] + +    if 'matrix_pins' in kb_info_json: +        if 'direct' in kb_info_json['matrix_pins']: +            col_num = len(kb_info_json['matrix_pins']['direct'][0]) +            row_num = len(kb_info_json['matrix_pins']['direct']) +        elif 'cols' in kb_info_json['matrix_pins'] and 'rows' in kb_info_json['matrix_pins']: +            col_num = len(kb_info_json['matrix_pins']['cols']) +            row_num = len(kb_info_json['matrix_pins']['rows']) +        else: +            cli.log.error('%s: Invalid matrix config.', cli.config.generate_layouts.keyboard) +            return False + +    for layout_name in kb_info_json['layouts']: +        if kb_info_json['layouts'][layout_name]['c_macro']: +            continue + +        if 'matrix' not in kb_info_json['layouts'][layout_name]['layout'][0]: +            cli.log.debug('%s/%s: No matrix data!', cli.config.generate_layouts.keyboard, layout_name) +            continue + +        layout_keys = [] +        layout_matrix = [['KC_NO' for i in range(col_num)] for i in range(row_num)] + +        for i, key in enumerate(kb_info_json['layouts'][layout_name]['layout']): +            row = key['matrix'][0] +            col = key['matrix'][1] +            identifier = 'k%s%s' % (ROW_LETTERS[row], COL_LETTERS[col]) + +            try: +                layout_matrix[row][col] = identifier +                layout_keys.append(identifier) +            except IndexError: +                key_name = key.get('label', identifier) +                cli.log.error('Matrix data out of bounds for layout %s at index %s (%s): %s, %s', layout_name, i, key_name, row, col) +                return False + +        layouts_h_lines.append('') +        layouts_h_lines.append('#define %s(%s) {\\' % (layout_name, ', '.join(layout_keys))) + +        rows = ', \\\n'.join(['\t {' + ', '.join(row) + '}' for row in layout_matrix]) +        rows += ' \\' +        layouts_h_lines.append(rows) +        layouts_h_lines.append('}') + +    # Show the results +    layouts_h = '\n'.join(layouts_h_lines) + '\n' + +    if cli.args.output: +        cli.args.output.parent.mkdir(parents=True, exist_ok=True) +        if cli.args.output.exists(): +            cli.args.output.replace(cli.args.output.name + '.bak') +        cli.args.output.write_text(layouts_h) + +        if not cli.args.quiet: +            cli.log.info('Wrote info_config.h to %s.', cli.args.output) + +    else: +        print(layouts_h) diff --git a/lib/python/qmk/cli/generate/rules_mk.py b/lib/python/qmk/cli/generate/rules_mk.py new file mode 100755 index 0000000000..af740f341d --- /dev/null +++ b/lib/python/qmk/cli/generate/rules_mk.py @@ -0,0 +1,91 @@ +"""Used by the make system to generate a rules.mk +""" +from pathlib import Path + +from dotty_dict import dotty +from milc import cli + +from qmk.decorators import automagic_keyboard, automagic_keymap +from qmk.info import _json_load, info_json +from qmk.path import is_keyboard, normpath + + +def process_mapping_rule(kb_info_json, rules_key, info_dict): +    """Return the rules.mk line(s) for a mapping rule. +    """ +    if not info_dict.get('to_c', True): +        return None + +    info_key = info_dict['info_key'] +    key_type = info_dict.get('value_type', 'str') + +    try: +        rules_value = kb_info_json[info_key] +    except KeyError: +        return None + +    if key_type == 'array': +        return f'{rules_key} ?= {" ".join(rules_value)}' +    elif key_type == 'bool': +        return f'{rules_key} ?= {"on" if rules_value else "off"}' +    elif key_type == 'mapping': +        return '\n'.join([f'{key} ?= {value}' for key, value in rules_value.items()]) + +    return f'{rules_key} ?= {rules_value}' + + [email protected]('-o', '--output', arg_only=True, type=normpath, help='File to write to') [email protected]('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") [email protected]('-kb', '--keyboard', help='Keyboard to generate config.h for.') [email protected]('Used by the make system to generate info_config.h from info.json', hidden=True) +@automagic_keyboard +@automagic_keymap +def generate_rules_mk(cli): +    """Generates a rules.mk file from info.json. +    """ +    if not cli.config.generate_rules_mk.keyboard: +        cli.log.error('Missing paramater: --keyboard') +        cli.subcommands['info'].print_help() +        return False + +    if not is_keyboard(cli.config.generate_rules_mk.keyboard): +        cli.log.error('Invalid keyboard: "%s"', cli.config.generate_rules_mk.keyboard) +        return False + +    kb_info_json = dotty(info_json(cli.config.generate_rules_mk.keyboard)) +    info_rules_map = _json_load(Path('data/mappings/info_rules.json')) +    rules_mk_lines = ['# This file was generated by `qmk generate-rules-mk`. Do not edit or copy.', ''] + +    # Iterate through the info_rules map to generate basic rules +    for rules_key, info_dict in info_rules_map.items(): +        new_entry = process_mapping_rule(kb_info_json, rules_key, info_dict) + +        if new_entry: +            rules_mk_lines.append(new_entry) + +    # Iterate through features to enable/disable them +    if 'features' in kb_info_json: +        for feature, enabled in kb_info_json['features'].items(): +            if feature == 'bootmagic_lite' and enabled: +                rules_mk_lines.append('BOOTMAGIC_ENABLE ?= lite') +            else: +                feature = feature.upper() +                enabled = 'yes' if enabled else 'no' +                rules_mk_lines.append(f'{feature}_ENABLE ?= {enabled}') + +    # Show the results +    rules_mk = '\n'.join(rules_mk_lines) + '\n' + +    if cli.args.output: +        cli.args.output.parent.mkdir(parents=True, exist_ok=True) +        if cli.args.output.exists(): +            cli.args.output.replace(cli.args.output.name + '.bak') +        cli.args.output.write_text(rules_mk) + +        if cli.args.quiet: +            print(cli.args.output) +        else: +            cli.log.info('Wrote rules.mk to %s.', cli.args.output) + +    else: +        print(rules_mk) diff --git a/lib/python/qmk/cli/info.py b/lib/python/qmk/cli/info.py index 9ab299a21e..87d7253d4b 100755 --- a/lib/python/qmk/cli/info.py +++ b/lib/python/qmk/cli/info.py @@ -7,6 +7,8 @@ import platform  from milc import cli +from qmk.info_json_encoder import InfoJSONEncoder +from qmk.constants import COL_LETTERS, ROW_LETTERS  from qmk.decorators import automagic_keyboard, automagic_keymap  from qmk.keyboard import render_layouts, render_layout  from qmk.keymap import locate_keymap @@ -15,9 +17,6 @@ from qmk.path import is_keyboard  platform_id = platform.platform().lower() -ROW_LETTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop' -COL_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijilmnopqrstuvwxyz' -  def show_keymap(kb_info_json, title_caps=True):      """Render the keymap in ascii art. @@ -149,7 +148,7 @@ def info(cli):      # Output in the requested format      if cli.args.format == 'json': -        print(json.dumps(kb_info_json)) +        print(json.dumps(kb_info_json, cls=InfoJSONEncoder))      elif cli.args.format == 'text':          print_text_output(kb_info_json)      elif cli.args.format == 'friendly': diff --git a/lib/python/qmk/cli/json/__init__.py b/lib/python/qmk/cli/json/__init__.py deleted file mode 100644 index f4ebfc45b4..0000000000 --- a/lib/python/qmk/cli/json/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""QMK CLI JSON Subcommands - -We list each subcommand here explicitly because all the reliable ways of searching for modules are slow and delay startup. -""" -from . import keymap diff --git a/lib/python/qmk/cli/json/keymap.py b/lib/python/qmk/cli/json/keymap.py deleted file mode 100755 index 2af9faaa72..0000000000 --- a/lib/python/qmk/cli/json/keymap.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Generate a keymap.c from a configurator export. -""" -from pathlib import Path - -from milc import cli - - [email protected]('-o', '--output', arg_only=True, type=Path, help='File to write to') [email protected]('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") [email protected]('filename', arg_only=True, help='Configurator JSON file') [email protected]('Creates a keymap.c from a QMK Configurator export.', hidden=True) -def json_keymap(cli): -    """Renamed to `qmk json2c`. -    """ -    cli.log.error('This command has been renamed to `qmk json2c`.') -    return False diff --git a/lib/python/qmk/cli/kle2json.py b/lib/python/qmk/cli/kle2json.py index 3d1bb8c43c..66d504bfc2 100755 --- a/lib/python/qmk/cli/kle2json.py +++ b/lib/python/qmk/cli/kle2json.py @@ -3,25 +3,12 @@  import json  import os  from pathlib import Path -from decimal import Decimal -from collections import OrderedDict  from milc import cli  from kle2xy import KLE2xy  from qmk.converter import kle2qmk - - -class CustomJSONEncoder(json.JSONEncoder): -    def default(self, obj): -        try: -            if isinstance(obj, Decimal): -                if obj % 2 in (Decimal(0), Decimal(1)): -                    return int(obj) -                return float(obj) -        except TypeError: -            pass -        return json.JSONEncoder.default(self, obj) +from qmk.info_json_encoder import InfoJSONEncoder  @cli.argument('filename', help='The KLE raw txt to convert') @@ -52,24 +39,22 @@ def kle2json(cli):          cli.log.error('Could not parse KLE raw data: %s', raw_code)          cli.log.exception(e)          return False -    keyboard = OrderedDict( -        keyboard_name=kle.name, -        url='', -        maintainer='qmk', -        width=kle.columns, -        height=kle.rows, -        layouts={'LAYOUT': { -            'layout': 'LAYOUT_JSON_HERE' -        }}, -    ) -    # Initialize keyboard with json encoded from ordered dict -    keyboard = json.dumps(keyboard, indent=4, separators=(', ', ': '), sort_keys=False, cls=CustomJSONEncoder) -    # Initialize layout with kle2qmk from converter module -    layout = json.dumps(kle2qmk(kle), separators=(', ', ':'), cls=CustomJSONEncoder) -    # Replace layout in keyboard json -    keyboard = keyboard.replace('"LAYOUT_JSON_HERE"', layout) +    keyboard = { +        'keyboard_name': kle.name, +        'url': '', +        'maintainer': 'qmk', +        'width': kle.columns, +        'height': kle.rows, +        'layouts': { +            'LAYOUT': { +                'layout': kle2qmk(kle) +            } +        }, +    } +      # Write our info.json -    file = open(out_path / "info.json", "w") -    file.write(keyboard) -    file.close() +    keyboard = json.dumps(keyboard, indent=4, separators=(', ', ': '), sort_keys=False, cls=InfoJSONEncoder) +    info_json_file = out_path / 'info.json' + +    info_json_file.write_text(keyboard)      cli.log.info('Wrote out {fg_cyan}%s/info.json', out_path) diff --git a/lib/python/qmk/constants.py b/lib/python/qmk/constants.py index 2ddaa568a2..3ed69f3bf9 100644 --- a/lib/python/qmk/constants.py +++ b/lib/python/qmk/constants.py @@ -10,8 +10,8 @@ QMK_FIRMWARE = Path.cwd()  MAX_KEYBOARD_SUBFOLDERS = 5  # Supported processor types -CHIBIOS_PROCESSORS = 'cortex-m0', 'cortex-m0plus', 'cortex-m3', 'cortex-m4', 'MKL26Z64', 'MK20DX128', 'MK20DX256', 'STM32F042', 'STM32F072', 'STM32F103', 'STM32F303', 'STM32F401', 'STM32F411' -LUFA_PROCESSORS = 'atmega16u2', 'atmega32u2', 'atmega16u4', 'atmega32u4', 'at90usb646', 'at90usb647', 'at90usb1286', 'at90usb1287', None +CHIBIOS_PROCESSORS = 'cortex-m0', 'cortex-m0plus', 'cortex-m3', 'cortex-m4', 'MKL26Z64', 'MK20DX128', 'MK20DX256', 'STM32F042', 'STM32F072', 'STM32F103', 'STM32F303', 'STM32F401', 'STM32F411', 'STM32G431', 'STM32G474' +LUFA_PROCESSORS = 'at90usb162', 'atmega16u2', 'atmega32u2', 'atmega16u4', 'atmega32u4', 'at90usb646', 'at90usb647', 'at90usb1286', 'at90usb1287', None  VUSB_PROCESSORS = 'atmega32a', 'atmega328p', 'atmega328', 'attiny85'  # Common format strings @@ -19,6 +19,17 @@ DATE_FORMAT = '%Y-%m-%d'  DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z'  TIME_FORMAT = '%H:%M:%S' +# Used when generating matrix locations +COL_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijilmnopqrstuvwxyz' +ROW_LETTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop' + +# Mapping between info.json and config.h keys +LED_INDICATORS = { +    'caps_lock': 'LED_CAPS_LOCK_PIN', +    'num_lock': 'LED_NUM_LOCK_PIN', +    'scroll_lock': 'LED_SCROLL_LOCK_PIN', +} +  # Constants that should match their counterparts in make  BUILD_DIR = environ.get('BUILD_DIR', '.build')  KEYBOARD_OUTPUT_PREFIX = f'{BUILD_DIR}/obj_' diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py index f476dc666d..2accaba9e4 100644 --- a/lib/python/qmk/info.py +++ b/lib/python/qmk/info.py @@ -1,9 +1,13 @@  """Functions that help us generate and use info.json files.  """  import json +from collections.abc import Mapping  from glob import glob  from pathlib import Path +import hjson +import jsonschema +from dotty_dict import dotty  from milc import cli  from qmk.constants import CHIBIOS_PROCESSORS, LUFA_PROCESSORS, VUSB_PROCESSORS @@ -13,6 +17,9 @@ from qmk.keymap import list_keymaps  from qmk.makefile import parse_rules_mk_file  from qmk.math import compute +true_values = ['1', 'on', 'yes'] +false_values = ['0', 'off', 'no'] +  def info_json(keyboard):      """Generate the info.json data for a specific keyboard. @@ -38,8 +45,9 @@ def info_json(keyboard):          info_data['keymaps'][keymap.name] = {'url': f'https://raw.githubusercontent.com/qmk/qmk_firmware/master/{keymap}/keymap.json'}      # Populate layout data -    for layout_name, layout_json in _find_all_layouts(info_data, keyboard, rules).items(): +    for layout_name, layout_json in _find_all_layouts(info_data, keyboard).items():          if not layout_name.startswith('LAYOUT_kc'): +            layout_json['c_macro'] = True              info_data['layouts'][layout_name] = layout_json      # Merge in the data from info.json, config.h, and rules.mk @@ -47,54 +55,259 @@ def info_json(keyboard):      info_data = _extract_config_h(info_data)      info_data = _extract_rules_mk(info_data) +    # Validate against the jsonschema +    try: +        keyboard_api_validate(info_data) + +    except jsonschema.ValidationError as e: +        json_path = '.'.join([str(p) for p in e.absolute_path]) +        cli.log.error('Invalid API data: %s: %s: %s', keyboard, json_path, e.message) +        exit() + +    # Make sure we have at least one layout +    if not info_data.get('layouts'): +        _log_error(info_data, 'No LAYOUTs defined! Need at least one layout defined in the keyboard.h or info.json.') + +    # Make sure we supply layout macros for the community layouts we claim to support +    # FIXME(skullydazed): This should be populated into info.json and read from there instead +    if 'LAYOUTS' in rules and info_data.get('layouts'): +        # Match these up against the supplied layouts +        supported_layouts = rules['LAYOUTS'].strip().split() +        for layout_name in sorted(info_data['layouts']): +            layout_name = layout_name[7:] + +            if layout_name in supported_layouts: +                supported_layouts.remove(layout_name) + +        if supported_layouts: +            for supported_layout in supported_layouts: +                _log_error(info_data, 'Claims to support community layout %s but no LAYOUT_%s() macro found' % (supported_layout, supported_layout)) +      return info_data -def _extract_config_h(info_data): -    """Pull some keyboard information from existing rules.mk files +def _json_load(json_file): +    """Load a json file from disk. + +    Note: file must be a Path object. +    """ +    try: +        return hjson.load(json_file.open()) + +    except json.decoder.JSONDecodeError as e: +        cli.log.error('Invalid JSON encountered attempting to load {fg_cyan}%s{fg_reset}:\n\t{fg_red}%s', json_file, e) +        exit(1) + + +def _jsonschema(schema_name): +    """Read a jsonschema file from disk. + +    FIXME(skullydazed/anyone): Refactor to make this a public function. +    """ +    schema_path = Path(f'data/schemas/{schema_name}.jsonschema') + +    if not schema_path.exists(): +        schema_path = Path('data/schemas/false.jsonschema') + +    return _json_load(schema_path) + + +def keyboard_validate(data): +    """Validates data against the keyboard jsonschema. +    """ +    schema = _jsonschema('keyboard') +    validator = jsonschema.Draft7Validator(schema).validate + +    return validator(data) + + +def keyboard_api_validate(data): +    """Validates data against the api_keyboard jsonschema. +    """ +    base = _jsonschema('keyboard') +    relative = _jsonschema('api_keyboard') +    resolver = jsonschema.RefResolver.from_schema(base) +    validator = jsonschema.Draft7Validator(relative, resolver=resolver).validate + +    return validator(data) + + +def _extract_features(info_data, rules): +    """Find all the features enabled in rules.mk. +    """ +    # Special handling for bootmagic which also supports a "lite" mode. +    if rules.get('BOOTMAGIC_ENABLE') == 'lite': +        rules['BOOTMAGIC_LITE_ENABLE'] = 'on' +        del rules['BOOTMAGIC_ENABLE'] +    if rules.get('BOOTMAGIC_ENABLE') == 'full': +        rules['BOOTMAGIC_ENABLE'] = 'on' + +    # Skip non-boolean features we haven't implemented special handling for +    for feature in 'HAPTIC_ENABLE', 'QWIIC_ENABLE': +        if rules.get(feature): +            del rules[feature] + +    # Process the rest of the rules as booleans +    for key, value in rules.items(): +        if key.endswith('_ENABLE'): +            key = '_'.join(key.split('_')[:-1]).lower() +            value = True if value.lower() in true_values else False if value.lower() in false_values else value + +            if 'config_h_features' not in info_data: +                info_data['config_h_features'] = {} + +            if 'features' not in info_data: +                info_data['features'] = {} + +            if key in info_data['features']: +                _log_warning(info_data, 'Feature %s is specified in both info.json and rules.mk, the rules.mk value wins.' % (key,)) + +            info_data['features'][key] = value +            info_data['config_h_features'][key] = value + +    return info_data + + +def _pin_name(pin): +    """Returns the proper representation for a pin. +    """ +    pin = pin.strip() + +    if not pin: +        return None + +    elif pin.isdigit(): +        return int(pin) + +    elif pin == 'NO_PIN': +        return None + +    elif pin[0] in 'ABCDEFGHIJK' and pin[1].isdigit(): +        return pin + +    raise ValueError(f'Invalid pin: {pin}') + + +def _extract_pins(pins): +    """Returns a list of pins from a comma separated string of pins. +    """ +    return [_pin_name(pin) for pin in pins.split(',')] + + +def _extract_direct_matrix(info_data, direct_pins): +    """ +    """ +    info_data['matrix_pins'] = {} +    direct_pin_array = [] + +    while direct_pins[-1] != '}': +        direct_pins = direct_pins[:-1] + +    for row in direct_pins.split('},{'): +        if row.startswith('{'): +            row = row[1:] + +        if row.endswith('}'): +            row = row[:-1] + +        direct_pin_array.append([]) + +        for pin in row.split(','): +            if pin == 'NO_PIN': +                pin = None + +            direct_pin_array[-1].append(pin) + +    return direct_pin_array + + +def _extract_matrix_info(info_data, config_c): +    """Populate the matrix information.      """ -    config_c = config_h(info_data['keyboard_folder'])      row_pins = config_c.get('MATRIX_ROW_PINS', '').replace('{', '').replace('}', '').strip()      col_pins = config_c.get('MATRIX_COL_PINS', '').replace('{', '').replace('}', '').strip()      direct_pins = config_c.get('DIRECT_PINS', '').replace(' ', '')[1:-1] -    info_data['diode_direction'] = config_c.get('DIODE_DIRECTION') -    info_data['matrix_size'] = { -        'rows': compute(config_c.get('MATRIX_ROWS', '0')), -        'cols': compute(config_c.get('MATRIX_COLS', '0')), -    } -    info_data['matrix_pins'] = {} +    if 'MATRIX_ROWS' in config_c and 'MATRIX_COLS' in config_c: +        if 'matrix_size' in info_data: +            _log_warning(info_data, 'Matrix size is specified in both info.json and config.h, the config.h values win.') + +        info_data['matrix_size'] = { +            'cols': compute(config_c.get('MATRIX_COLS', '0')), +            'rows': compute(config_c.get('MATRIX_ROWS', '0')), +        } -    if row_pins: -        info_data['matrix_pins']['rows'] = row_pins.split(',') -    if col_pins: -        info_data['matrix_pins']['cols'] = col_pins.split(',') +    if row_pins and col_pins: +        if 'matrix_pins' in info_data: +            _log_warning(info_data, 'Matrix pins are specified in both info.json and config.h, the config.h values win.') + +        info_data['matrix_pins'] = { +            'cols': _extract_pins(col_pins), +            'rows': _extract_pins(row_pins), +        }      if direct_pins: -        direct_pin_array = [] -        for row in direct_pins.split('},{'): -            if row.startswith('{'): -                row = row[1:] -            if row.endswith('}'): -                row = row[:-1] +        if 'matrix_pins' in info_data: +            _log_warning(info_data, 'Direct pins are specified in both info.json and config.h, the config.h values win.') -            direct_pin_array.append([]) +        info_data['matrix_pins']['direct'] = _extract_direct_matrix(info_data, direct_pins) -            for pin in row.split(','): -                if pin == 'NO_PIN': -                    pin = None +    return info_data -                direct_pin_array[-1].append(pin) -        info_data['matrix_pins']['direct'] = direct_pin_array +def _extract_config_h(info_data): +    """Pull some keyboard information from existing config.h files +    """ +    config_c = config_h(info_data['keyboard_folder']) -    info_data['usb'] = { -        'vid': config_c.get('VENDOR_ID'), -        'pid': config_c.get('PRODUCT_ID'), -        'device_ver': config_c.get('DEVICE_VER'), -        'manufacturer': config_c.get('MANUFACTURER'), -        'product': config_c.get('PRODUCT'), -    } +    # Pull in data from the json map +    dotty_info = dotty(info_data) +    info_config_map = _json_load(Path('data/mappings/info_config.json')) + +    for config_key, info_dict in info_config_map.items(): +        info_key = info_dict['info_key'] +        key_type = info_dict.get('value_type', 'str') + +        try: +            if config_key in config_c and info_dict.get('to_json', True): +                if dotty_info.get(info_key) and info_dict.get('warn_duplicate', True): +                    _log_warning(info_data, '%s in config.h is overwriting %s in info.json' % (config_key, info_key)) + +                if key_type.startswith('array'): +                    if '.' in key_type: +                        key_type, array_type = key_type.split('.', 1) +                    else: +                        array_type = None + +                    config_value = config_c[config_key].replace('{', '').replace('}', '').strip() + +                    if array_type == 'int': +                        dotty_info[info_key] = list(map(int, config_value.split(','))) +                    else: +                        dotty_info[info_key] = config_value.split(',') + +                elif key_type == 'bool': +                    dotty_info[info_key] = config_c[config_key] in true_values + +                elif key_type == 'hex': +                    dotty_info[info_key] = '0x' + config_c[config_key][2:].upper() + +                elif key_type == 'list': +                    dotty_info[info_key] = config_c[config_key].split() + +                elif key_type == 'int': +                    dotty_info[info_key] = int(config_c[config_key]) + +                else: +                    dotty_info[info_key] = config_c[config_key] + +        except Exception as e: +            _log_warning(info_data, f'{config_key}->{info_key}: {e}') + +    info_data.update(dotty_info) + +    # Pull data that easily can't be mapped in json +    _extract_matrix_info(info_data, config_c)      return info_data @@ -103,19 +316,101 @@ def _extract_rules_mk(info_data):      """Pull some keyboard information from existing rules.mk files      """      rules = rules_mk(info_data['keyboard_folder']) -    mcu = rules.get('MCU') +    info_data['processor'] = rules.get('MCU', info_data.get('processor', 'atmega32u4')) + +    if info_data['processor'] in CHIBIOS_PROCESSORS: +        arm_processor_rules(info_data, rules) + +    elif info_data['processor'] in LUFA_PROCESSORS + VUSB_PROCESSORS: +        avr_processor_rules(info_data, rules) + +    else: +        cli.log.warning("%s: Unknown MCU: %s" % (info_data['keyboard_folder'], info_data['processor'])) +        unknown_processor_rules(info_data, rules) + +    # Pull in data from the json map +    dotty_info = dotty(info_data) +    info_rules_map = _json_load(Path('data/mappings/info_rules.json')) -    if mcu in CHIBIOS_PROCESSORS: -        return arm_processor_rules(info_data, rules) +    for rules_key, info_dict in info_rules_map.items(): +        info_key = info_dict['info_key'] +        key_type = info_dict.get('value_type', 'str') -    elif mcu in LUFA_PROCESSORS + VUSB_PROCESSORS: -        return avr_processor_rules(info_data, rules) +        try: +            if rules_key in rules and info_dict.get('to_json', True): +                if dotty_info.get(info_key) and info_dict.get('warn_duplicate', True): +                    _log_warning(info_data, '%s in rules.mk is overwriting %s in info.json' % (rules_key, info_key)) + +                if key_type.startswith('array'): +                    if '.' in key_type: +                        key_type, array_type = key_type.split('.', 1) +                    else: +                        array_type = None -    msg = "Unknown MCU: " + str(mcu) +                    rules_value = rules[rules_key].replace('{', '').replace('}', '').strip() + +                    if array_type == 'int': +                        dotty_info[info_key] = list(map(int, rules_value.split(','))) +                    else: +                        dotty_info[info_key] = rules_value.split(',') -    _log_warning(info_data, msg) +                elif key_type == 'list': +                    dotty_info[info_key] = rules[rules_key].split() -    return unknown_processor_rules(info_data, rules) +                elif key_type == 'bool': +                    dotty_info[info_key] = rules[rules_key] in true_values + +                elif key_type == 'hex': +                    dotty_info[info_key] = '0x' + rules[rules_key][2:].upper() + +                elif key_type == 'int': +                    dotty_info[info_key] = int(rules[rules_key]) + +                else: +                    dotty_info[info_key] = rules[rules_key] + +        except Exception as e: +            _log_warning(info_data, f'{rules_key}->{info_key}: {e}') + +    info_data.update(dotty_info) + +    # Merge in config values that can't be easily mapped +    _extract_features(info_data, rules) + +    return info_data + + +def _merge_layouts(info_data, new_info_data): +    """Merge new_info_data into info_data in an intelligent way. +    """ +    for layout_name, layout_json in new_info_data['layouts'].items(): +        if layout_name in info_data['layouts']: +            # Pull in layouts we have a macro for +            if len(info_data['layouts'][layout_name]['layout']) != len(layout_json['layout']): +                msg = '%s: %s: Number of elements in info.json does not match! info.json:%s != %s:%s' +                _log_error(info_data, msg % (info_data['keyboard_folder'], layout_name, len(layout_json['layout']), layout_name, len(info_data['layouts'][layout_name]['layout']))) +            else: +                for i, key in enumerate(info_data['layouts'][layout_name]['layout']): +                    key.update(layout_json['layout'][i]) +        else: +            # Pull in layouts that have matrix data +            missing_matrix = False +            for key in layout_json.get('layout', {}): +                if 'matrix' not in key: +                    missing_matrix = True + +            if not missing_matrix: +                if layout_name in info_data['layouts']: +                    # Update an existing layout with new data +                    for i, key in enumerate(info_data['layouts'][layout_name]['layout']): +                        key.update(layout_json['layout'][i]) + +                else: +                    # Copy in the new layout wholesale +                    layout_json['c_macro'] = False +                    info_data['layouts'][layout_name] = layout_json + +    return info_data  def _search_keyboard_h(path): @@ -131,34 +426,21 @@ def _search_keyboard_h(path):      return layouts -def _find_all_layouts(info_data, keyboard, rules): +def _find_all_layouts(info_data, keyboard):      """Looks for layout macros associated with this keyboard.      """      layouts = _search_keyboard_h(Path(keyboard))      if not layouts: -        # If we didn't find any layouts above we widen our search. This is error -        # prone which is why we want to encourage people to follow the standard above. -        _log_warning(info_data, 'Falling back to searching for KEYMAP/LAYOUT macros.') +        # If we don't find any layouts from info.json or keyboard.h we widen our search. This is error prone which is why we want to encourage people to follow the standard above. +        info_data['parse_warnings'].append('%s: Falling back to searching for KEYMAP/LAYOUT macros.' % (keyboard)) +          for file in glob('keyboards/%s/*.h' % keyboard):              if file.endswith('.h'):                  these_layouts = find_layouts(file)                  if these_layouts:                      layouts.update(these_layouts) -    if 'LAYOUTS' in rules: -        # Match these up against the supplied layouts -        supported_layouts = rules['LAYOUTS'].strip().split() -        for layout_name in sorted(layouts): -            if not layout_name.startswith('LAYOUT_'): -                continue -            layout_name = layout_name[7:] -            if layout_name in supported_layouts: -                supported_layouts.remove(layout_name) - -        if supported_layouts: -            _log_error(info_data, 'Missing LAYOUT() macro for %s' % (', '.join(supported_layouts))) -      return layouts @@ -180,13 +462,13 @@ def arm_processor_rules(info_data, rules):      """Setup the default info for an ARM board.      """      info_data['processor_type'] = 'arm' -    info_data['bootloader'] = rules['BOOTLOADER'] if 'BOOTLOADER' in rules else 'unknown' -    info_data['processor'] = rules['MCU'] if 'MCU' in rules else 'unknown'      info_data['protocol'] = 'ChibiOS' -    if info_data['bootloader'] == 'unknown': +    if 'bootloader' not in info_data:          if 'STM32' in info_data['processor']:              info_data['bootloader'] = 'stm32-dfu' +        else: +            info_data['bootloader'] = 'unknown'      if 'STM32' in info_data['processor']:          info_data['platform'] = 'STM32' @@ -202,11 +484,12 @@ def avr_processor_rules(info_data, rules):      """Setup the default info for an AVR board.      """      info_data['processor_type'] = 'avr' -    info_data['bootloader'] = rules['BOOTLOADER'] if 'BOOTLOADER' in rules else 'atmel-dfu'      info_data['platform'] = rules['ARCH'] if 'ARCH' in rules else 'unknown' -    info_data['processor'] = rules['MCU'] if 'MCU' in rules else 'unknown'      info_data['protocol'] = 'V-USB' if rules.get('MCU') in VUSB_PROCESSORS else 'LUFA' +    if 'bootloader' not in info_data: +        info_data['bootloader'] = 'atmel-dfu' +      # FIXME(fauxpark/anyone): Eventually we should detect the protocol by looking at PROTOCOL inherited from mcu_selection.mk:      # info_data['protocol'] = 'V-USB' if rules.get('PROTOCOL') == 'VUSB' else 'LUFA' @@ -225,38 +508,44 @@ def unknown_processor_rules(info_data, rules):      return info_data +def deep_update(origdict, newdict): +    """Update a dictionary in place, recursing to do a deep copy. +    """ +    for key, value in newdict.items(): +        if isinstance(value, Mapping): +            origdict[key] = deep_update(origdict.get(key, {}), value) + +        else: +            origdict[key] = value + +    return origdict + +  def merge_info_jsons(keyboard, info_data):      """Return a merged copy of all the info.json files for a keyboard.      """      for info_file in find_info_json(keyboard):          # Load and validate the JSON data -        try: -            with info_file.open('r') as info_fd: -                new_info_data = json.load(info_fd) -        except Exception as e: -            _log_error(info_data, "Invalid JSON in file %s: %s: %s" % (str(info_file), e.__class__.__name__, e)) -            continue +        new_info_data = _json_load(info_file)          if not isinstance(new_info_data, dict):              _log_error(info_data, "Invalid file %s, root object should be a dictionary." % (str(info_file),))              continue -        # Copy whitelisted keys into `info_data` -        for key in ('keyboard_name', 'manufacturer', 'identifier', 'url', 'maintainer', 'processor', 'bootloader', 'width', 'height'): -            if key in new_info_data: -                info_data[key] = new_info_data[key] +        try: +            keyboard_validate(new_info_data) +        except jsonschema.ValidationError as e: +            json_path = '.'.join([str(p) for p in e.absolute_path]) +            cli.log.error('Not including data from file: %s', info_file) +            cli.log.error('\t%s: %s', json_path, e.message) +            continue + +        # Mark the layouts as coming from json +        for layout in new_info_data.get('layouts', {}).values(): +            layout['c_macro'] = False -        # Merge the layouts in -        if 'layouts' in new_info_data: -            for layout_name, json_layout in new_info_data['layouts'].items(): -                # Only pull in layouts we have a macro for -                if layout_name in info_data['layouts']: -                    if info_data['layouts'][layout_name]['key_count'] != len(json_layout['layout']): -                        msg = '%s: Number of elements in info.json does not match! info.json:%s != %s:%s' -                        _log_error(info_data, msg % (layout_name, len(json_layout['layout']), layout_name, len(info_data['layouts'][layout_name]['layout']))) -                    else: -                        for i, key in enumerate(info_data['layouts'][layout_name]['layout']): -                            key.update(json_layout['layout'][i]) +        # Update info_data with the new data +        deep_update(info_data, new_info_data)      return info_data diff --git a/lib/python/qmk/info_json_encoder.py b/lib/python/qmk/info_json_encoder.py new file mode 100755 index 0000000000..60dae7247f --- /dev/null +++ b/lib/python/qmk/info_json_encoder.py @@ -0,0 +1,96 @@ +"""Class that pretty-prints QMK info.json files. +""" +import json +from decimal import Decimal + + +class InfoJSONEncoder(json.JSONEncoder): +    """Custom encoder to make info.json's a little nicer to work with. +    """ +    container_types = (list, tuple, dict) +    indentation_char = " " + +    def __init__(self, *args, **kwargs): +        super().__init__(*args, **kwargs) +        self.indentation_level = 0 + +        if not self.indent: +            self.indent = 4 + +    def encode(self, obj): +        """Encode JSON objects for QMK. +        """ +        if isinstance(obj, Decimal): +            if obj == int(obj):  # I can't believe Decimal objects don't have .is_integer() +                return int(obj) +            return float(obj) + +        elif isinstance(obj, (list, tuple)): +            if self._primitives_only(obj): +                return "[" + ", ".join(self.encode(element) for element in obj) + "]" + +            else: +                self.indentation_level += 1 +                output = [self.indent_str + self.encode(element) for element in obj] +                self.indentation_level -= 1 +                return "[\n" + ",\n".join(output) + "\n" + self.indent_str + "]" + +        elif isinstance(obj, dict): +            if obj: +                if self.indentation_level == 4: +                    # These are part of a layout, put them on a single line. +                    return "{ " + ", ".join(f"{self.encode(key)}: {self.encode(element)}" for key, element in sorted(obj.items())) + " }" + +                else: +                    self.indentation_level += 1 +                    output = [self.indent_str + f"{json.dumps(key)}: {self.encode(value)}" for key, value in sorted(obj.items(), key=self.sort_root_dict)] +                    self.indentation_level -= 1 +                    return "{\n" + ",\n".join(output) + "\n" + self.indent_str + "}" +            else: +                return "{}" +        else: +            return super().encode(obj) + +    def _primitives_only(self, obj): +        """Returns true if the object doesn't have any container type objects (list, tuple, dict). +        """ +        if isinstance(obj, dict): +            obj = obj.values() + +        return not any(isinstance(element, self.container_types) for element in obj) + +    def sort_root_dict(self, key): +        """Forces layout to the back of the sort order. +        """ +        key = key[0] + +        if self.indentation_level == 1: +            if key == 'manufacturer': +                return '10keyboard_name' + +            elif key == 'keyboard_name': +                return '11keyboard_name' + +            elif key == 'maintainer': +                return '12maintainer' + +            elif key in ('height', 'width'): +                return '40' + str(key) + +            elif key == 'community_layouts': +                return '97community_layouts' + +            elif key == 'layout_aliases': +                return '98layout_aliases' + +            elif key == 'layouts': +                return '99layouts' + +            else: +                return '50' + str(key) + +        return key + +    @property +    def indent_str(self): +        return self.indentation_char * (self.indentation_level * self.indent) diff --git a/lib/python/qmk/os_helpers/linux/__init__.py b/lib/python/qmk/os_helpers/linux/__init__.py index 86850bf284..a04ac4f8a9 100644 --- a/lib/python/qmk/os_helpers/linux/__init__.py +++ b/lib/python/qmk/os_helpers/linux/__init__.py @@ -48,6 +48,7 @@ def check_udev_rules():              _udev_rule("03eb", "2ff3"),  # ATmega16U4              _udev_rule("03eb", "2ff4"),  # ATmega32U4              _udev_rule("03eb", "2ff9"),  # AT90USB64 +            _udev_rule("03eb", "2ffa"),  # AT90USB162              _udev_rule("03eb", "2ffb")  # AT90USB128          },          'kiibohd': {_udev_rule("1c11", "b007")}, diff --git a/lib/python/qmk/tests/test_cli_commands.py b/lib/python/qmk/tests/test_cli_commands.py index f889833d0b..3efeddb85e 100644 --- a/lib/python/qmk/tests/test_cli_commands.py +++ b/lib/python/qmk/tests/test_cli_commands.py @@ -230,3 +230,32 @@ def test_generate_rgb_breathe_table():      check_returncode(result)      assert 'Breathing center: 1.2' in result.stdout      assert 'Breathing max:    127' in result.stdout + + +def test_generate_config_h(): +    result = check_subcommand('generate-config-h', '-kb', 'handwired/pytest/basic') +    check_returncode(result) +    assert '#   define DEVICE_VER 0x0001' in result.stdout +    assert '#   define DESCRIPTION handwired/pytest/basic' in result.stdout +    assert '#   define DIODE_DIRECTION COL2ROW' in result.stdout +    assert '#   define MANUFACTURER none' in result.stdout +    assert '#   define PRODUCT handwired/pytest/basic' in result.stdout +    assert '#   define PRODUCT_ID 0x6465' in result.stdout +    assert '#   define VENDOR_ID 0xFEED' in result.stdout +    assert '#   define MATRIX_COLS 1' in result.stdout +    assert '#   define MATRIX_COL_PINS { F4 }' in result.stdout +    assert '#   define MATRIX_ROWS 1' in result.stdout +    assert '#   define MATRIX_ROW_PINS { F5 }' in result.stdout + + +def test_generate_rules_mk(): +    result = check_subcommand('generate-rules-mk', '-kb', 'handwired/pytest/basic') +    check_returncode(result) +    assert 'BOOTLOADER ?= atmel-dfu' in result.stdout +    assert 'MCU ?= atmega32u4' in result.stdout + + +def test_generate_layouts(): +    result = check_subcommand('generate-layouts', '-kb', 'handwired/pytest/basic') +    check_returncode(result) +    assert '#define LAYOUT_custom(k0A) {' in result.stdout | 
