qmk_firmware

QMK firmware for my keyboards (Corne, Sweep Ferris) and trackball (Ploopy Adept)
Log | Files | Refs | Submodules | LICENSE

rules_mk.py (4708B)

      1 """Used by the make system to generate a rules.mk
      2 """
      3 from pathlib import Path
      4 from dotty_dict import dotty
      5 
      6 from argcomplete.completers import FilesCompleter
      7 from milc import cli
      8 
      9 from qmk.info import info_json
     10 from qmk.json_schema import json_load
     11 from qmk.keyboard import keyboard_completer, keyboard_folder
     12 from qmk.commands import dump_lines, parse_configurator_json
     13 from qmk.path import normpath, FileType
     14 from qmk.constants import GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE
     15 
     16 
     17 def generate_rule(rules_key, rules_value):
     18     is_keymap = cli.args.filename
     19     rule_assignment_operator = '=' if is_keymap else '?='
     20     return f'{rules_key} {rule_assignment_operator} {rules_value}'
     21 
     22 
     23 def process_mapping_rule(kb_info_json, rules_key, info_dict):
     24     """Return the rules.mk line(s) for a mapping rule.
     25     """
     26     if not info_dict.get('to_c', True):
     27         return None
     28 
     29     info_key = info_dict['info_key']
     30     key_type = info_dict.get('value_type', 'raw')
     31 
     32     try:
     33         rules_value = kb_info_json[info_key]
     34     except KeyError:
     35         return None
     36 
     37     if key_type in ['array', 'list']:
     38         return generate_rule(rules_key, " ".join(rules_value))
     39     elif key_type == 'bool':
     40         return generate_rule(rules_key, "yes" if rules_value else "no")
     41     elif key_type == 'mapping':
     42         return '\n'.join([generate_rule(key, value) for key, value in rules_value.items()])
     43     elif key_type == 'str':
     44         return generate_rule(rules_key, f'"{rules_value}"')
     45 
     46     return generate_rule(rules_key, rules_value)
     47 
     48 
     49 def generate_features_rules(features_dict):
     50     lines = []
     51     for feature, enabled in features_dict.items():
     52         feature = feature.upper()
     53         enabled = 'yes' if enabled else 'no'
     54         lines.append(generate_rule(f'{feature}_ENABLE', enabled))
     55     return lines
     56 
     57 
     58 @cli.argument('filename', nargs='?', arg_only=True, type=FileType('r'), completer=FilesCompleter('.json'), help='A configurator export JSON to be compiled and flashed or a pre-compiled binary firmware file (bin/hex) to be flashed.')
     59 @cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
     60 @cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
     61 @cli.argument('-e', '--escape', arg_only=True, action='store_true', help="Escape spaces in quiet mode")
     62 @cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate rules.mk for.')
     63 @cli.subcommand('Used by the make system to generate rules.mk from info.json', hidden=True)
     64 def generate_rules_mk(cli):
     65     """Generates a rules.mk file from info.json.
     66     """
     67     converter = None
     68     # Determine our keyboard/keymap
     69     if cli.args.filename:
     70         user_keymap = parse_configurator_json(cli.args.filename)
     71         kb_info_json = dotty(user_keymap.get('config', {}))
     72         converter = user_keymap.get('converter', None)
     73     elif cli.args.keyboard:
     74         kb_info_json = dotty(info_json(cli.args.keyboard))
     75     else:
     76         cli.log.error('You must supply a configurator export or `--keyboard`.')
     77         cli.subcommands['generate-rules-mk'].print_help()
     78         return False
     79 
     80     info_rules_map = json_load(Path('data/mappings/info_rules.hjson'))
     81     rules_mk_lines = [GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE]
     82 
     83     # Iterate through the info_rules map to generate basic rules
     84     for rules_key, info_dict in info_rules_map.items():
     85         new_entry = process_mapping_rule(kb_info_json, rules_key, info_dict)
     86 
     87         if new_entry:
     88             rules_mk_lines.append(new_entry)
     89 
     90     # Iterate through features to enable/disable them
     91     if 'features' in kb_info_json:
     92         rules_mk_lines.extend(generate_features_rules(kb_info_json['features']))
     93 
     94     # Set SPLIT_TRANSPORT, if needed
     95     if kb_info_json.get('split', {}).get('transport', {}).get('protocol') == 'custom':
     96         rules_mk_lines.append(generate_rule('SPLIT_TRANSPORT', 'custom'))
     97 
     98     # Set CUSTOM_MATRIX, if needed
     99     if kb_info_json.get('matrix_pins', {}).get('custom_lite'):
    100         rules_mk_lines.append(generate_rule('CUSTOM_MATRIX', 'lite'))
    101     elif kb_info_json.get('matrix_pins', {}).get('custom'):
    102         rules_mk_lines.append(generate_rule('CUSTOM_MATRIX', 'yes'))
    103 
    104     if converter:
    105         rules_mk_lines.append(generate_rule('CONVERT_TO', converter))
    106 
    107     # Show the results
    108     dump_lines(cli.args.output, rules_mk_lines)
    109 
    110     if cli.args.output:
    111         if cli.args.quiet:
    112             if cli.args.escape:
    113                 print(cli.args.output.as_posix().replace(' ', '\\ '))
    114             else:
    115                 print(cli.args.output)
    116         else:
    117             cli.log.info('Wrote rules.mk to %s.', cli.args.output)