2021 February 27 Breaking Changes Update (#12040)

20 files changed, 1050 insertions, 188 deletions

diff --git a/lib/python/qmk/c_parse.py b/lib/python/qmk/c_parse.py
index e41e271a4..d4f39c883 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):
@@ -31,7 +46,7 @@ def find_layouts(file):
     parsed_layouts = {}
 
     # Search the file for LAYOUT macros and aliases
-    file_contents = file.read_text()
+    file_contents = file.read_text(encoding='utf-8')
     file_contents = comment_remover(file_contents)
     file_contents = file_contents.replace('\\\n', '')
 
@@ -52,8 +67,11 @@ def find_layouts(file):
             layout = layout.strip()
             parsed_layout = [_default_key(key) for key in layout.split(',')]
 
-            for key in parsed_layout:
-                key['matrix'] = matrix_locations.get(key['label'])
+            for i, key in enumerate(parsed_layout):
+                if 'label' not in key:
+                    cli.log.error('Invalid LAYOUT macro in %s: Empty parameter name in macro %s at pos %s.', file, macro_name, i)
+                elif key['label'] in matrix_locations:
+                    key['matrix'] = matrix_locations[key['label']]
 
             parsed_layouts[macro_name] = {
                 'key_count': len(parsed_layout),
@@ -69,12 +87,7 @@ def find_layouts(file):
             except ValueError:
                 continue
 
-    # Populate our aliases
-    for alias, text in aliases.items():
-        if text in parsed_layouts and 'KEYMAP' not in alias:
-            parsed_layouts[alias] = parsed_layouts[text]
-
-    return parsed_layouts
+    return parsed_layouts, aliases
 
 
 def parse_config_h_file(config_h_file, config_h=None):
@@ -86,14 +99,12 @@ def parse_config_h_file(config_h_file, config_h=None):
     config_h_file = Path(config_h_file)
 
     if config_h_file.exists():
-        config_h_text = config_h_file.read_text()
+        config_h_text = config_h_file.read_text(encoding='utf-8')
         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 +167,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 372c40921..a5f1f4767 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 2b3bb774f..8f9d8dc38 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 b9cfda961..89995931a 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
@@ -40,7 +40,7 @@ file_header = """\
 
 
 def collect_defines(filepath):
-    with open(filepath, 'r') as f:
+    with open(filepath, 'r', encoding='utf-8') as f:
         content = f.read()
         define_search = re.compile(r'(?m)^#\s*define\s+(?:.*\\\r?\n)*.*$', re.MULTILINE)
         value_search = re.compile(r'^#\s*define\s+(?P<name>[a-zA-Z0-9_]+(\([^\)]*\))?)\s*(?P<value>.*)', re.DOTALL)
@@ -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.')
+@cli.argument('-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,20 +143,20 @@ 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:
+                with open(cli.args.input, "w", encoding='utf-8') 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:
+                with open(cli.args.input, "w", encoding='utf-8') 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:
+                with open(cli.args.input, "w", encoding='utf-8') as out_file:
                     migrate_mcuconf_h(to_override, outfile=out_file)
diff --git a/lib/python/qmk/cli/generate/__init__.py b/lib/python/qmk/cli/generate/__init__.py
index f9585bfb5..bd75b044c 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 66db37cb5..6d111f244 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 000000000..7ddad745d
--- /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)
+
+
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', help='Keyboard to generate config.h for.')
+@cli.subcommand('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 000000000..f3fc54ddc
--- /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)
+
+
+@cli.argument('-kb', '--keyboard', help='Keyboard to show info for.')
+@cli.argument('-km', '--keymap', help='Show the layers for a JSON keymap too.')
+@cli.subcommand('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 000000000..15b289522
--- /dev/null
+++ b/lib/python/qmk/cli/generate/layouts.py
@@ -0,0 +1,102 @@
+"""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',
+}
+
+
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', help='Keyboard to generate config.h for.')
+@cli.subcommand('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('}')
+
+    for alias, target in kb_info_json.get('layout_aliases', {}).items():
+        layouts_h_lines.append('')
+        layouts_h_lines.append('#define %s %s' % (alias, target))
+
+    # 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 000000000..af740f341
--- /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}'
+
+
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', help='Keyboard to generate config.h for.')
+@cli.subcommand('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 9ab299a21..a7ce8abf0 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.
@@ -30,7 +29,7 @@ def show_keymap(kb_info_json, title_caps=True):
         else:
             cli.echo('{fg_blue}keymap_%s{fg_reset}:', cli.config.info.keymap)
 
-        keymap_data = json.load(keymap_path.open())
+        keymap_data = json.load(keymap_path.open(encoding='utf-8'))
         layout_name = keymap_data['layout']
 
         for layer_num, layer in enumerate(keymap_data['layers']):
@@ -58,7 +57,7 @@ def show_matrix(kb_info_json, title_caps=True):
         # Build our label list
         labels = []
         for key in layout['layout']:
-            if key['matrix']:
+            if 'matrix' in key:
                 row = ROW_LETTERS[key['matrix'][0]]
                 col = COL_LETTERS[key['matrix'][1]]
 
@@ -92,6 +91,9 @@ def print_friendly_output(kb_info_json):
         cli.echo('{fg_blue}Size{fg_reset}: %s x %s' % (kb_info_json['width'], kb_info_json['height']))
     cli.echo('{fg_blue}Processor{fg_reset}: %s', kb_info_json.get('processor', 'Unknown'))
     cli.echo('{fg_blue}Bootloader{fg_reset}: %s', kb_info_json.get('bootloader', 'Unknown'))
+    if 'layout_aliases' in kb_info_json:
+        aliases = [f'{key}={value}' for key, value in kb_info_json['layout_aliases'].items()]
+        cli.echo('{fg_blue}Layout aliases:{fg_reset} %s' % (', '.join(aliases),))
 
     if cli.config.info.layouts:
         show_layouts(kb_info_json, True)
@@ -149,7 +151,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 f4ebfc45b..000000000
--- 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 2af9faaa7..000000000
--- 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
-
-
-@cli.argument('-o', '--output', arg_only=True, type=Path, help='File to write to')
-@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
-@cli.argument('filename', arg_only=True, help='Configurator JSON file')
-@cli.subcommand('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 3d1bb8c43..3bb744358 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')
@@ -40,7 +27,7 @@ def kle2json(cli):
         cli.log.error('File {fg_cyan}%s{style_reset_all} was not found.', file_path)
         return False
     out_path = file_path.parent
-    raw_code = file_path.open().read()
+    raw_code = file_path.read_text(encoding='utf-8')
     # Check if info.json exists, allow overwrite with force
     if Path(out_path, "info.json").exists() and not cli.args.force:
         cli.log.error('File {fg_cyan}%s/info.json{style_reset_all} already exists, use -f or --force to overwrite.', out_path)
@@ -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 2ddaa568a..3ed69f3bf 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 f476dc666..cf5dc6640 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,14 @@ 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():
+    layouts, aliases = _find_all_layouts(info_data, keyboard)
+
+    if aliases:
+        info_data['layout_aliases'] = aliases
+
+    for layout_name, layout_json in layouts.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 +60,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(encoding='utf-8'))
+
+    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.')
+
+        info_data['matrix_pins']['direct'] = _extract_direct_matrix(info_data, direct_pins)
+
+    return info_data
+
 
-            direct_pin_array.append([])
+def _extract_config_h(info_data):
+    """Pull some keyboard information from existing config.h files
+    """
+    config_c = config_h(info_data['keyboard_folder'])
 
-            for pin in row.split(','):
-                if pin == 'NO_PIN':
-                    pin = None
+    # Pull in data from the json map
+    dotty_info = dotty(info_data)
+    info_config_map = _json_load(Path('data/mappings/info_config.json'))
 
-                direct_pin_array[-1].append(pin)
+    for config_key, info_dict in info_config_map.items():
+        info_key = info_dict['info_key']
+        key_type = info_dict.get('value_type', 'str')
 
-        info_data['matrix_pins']['direct'] = direct_pin_array
+        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))
 
-    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'),
-    }
+                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,63 +321,143 @@ 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'))
+
+    for rules_key, info_dict in info_rules_map.items():
+        info_key = info_dict['info_key']
+        key_type = info_dict.get('value_type', 'str')
+
+        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
+
+                    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(',')
+
+                elif key_type == 'list':
+                    dotty_info[info_key] = rules[rules_key].split()
+
+                elif key_type == 'bool':
+                    dotty_info[info_key] = rules[rules_key] in true_values
 
-    if mcu in CHIBIOS_PROCESSORS:
-        return arm_processor_rules(info_data, rules)
+                elif key_type == 'hex':
+                    dotty_info[info_key] = '0x' + rules[rules_key][2:].upper()
 
-    elif mcu in LUFA_PROCESSORS + VUSB_PROCESSORS:
-        return avr_processor_rules(info_data, rules)
+                elif key_type == 'int':
+                    dotty_info[info_key] = int(rules[rules_key])
 
-    msg = "Unknown MCU: " + str(mcu)
+                else:
+                    dotty_info[info_key] = rules[rules_key]
 
-    _log_warning(info_data, msg)
+        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
 
-    return unknown_processor_rules(info_data, rules)
+
+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):
     current_path = Path('keyboards/')
+    aliases = {}
     layouts = {}
+
     for directory in path.parts:
         current_path = current_path / directory
         keyboard_h = '%s.h' % (directory,)
         keyboard_h_path = current_path / keyboard_h
         if keyboard_h_path.exists():
-            layouts.update(find_layouts(keyboard_h_path))
+            new_layouts, new_aliases = find_layouts(keyboard_h_path)
+            layouts.update(new_layouts)
+
+            for alias, alias_text in new_aliases.items():
+                if alias_text in layouts:
+                    aliases[alias] = alias_text
 
-    return layouts
+    return layouts, aliases
 
 
-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))
+    layouts, aliases = _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)
+                these_layouts, these_aliases = 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)))
+                if these_aliases:
+                    aliases.update(these_aliases)
 
-    return layouts
+    return layouts, aliases
 
 
 def _log_error(info_data, message):
@@ -180,13 +478,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 +500,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 +524,52 @@ 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
 
-        # Merge the layouts in
+        # Merge layout data in
+        for layout_name, layout in new_info_data.get('layouts', {}).items():
+            if layout_name in info_data['layouts']:
+                for new_key, existing_key in zip(layout['layout'], info_data['layouts'][layout_name]['layout']):
+                    existing_key.update(new_key)
+            else:
+                layout['c_macro'] = False
+                info_data['layouts'][layout_name] = layout
+
+        # Update info_data with the new data
         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])
+            del (new_info_data['layouts'])
+
+        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 000000000..60dae7247
--- /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/keymap.py b/lib/python/qmk/keymap.py
index 266532f50..d8495c38b 100644
--- a/lib/python/qmk/keymap.py
+++ b/lib/python/qmk/keymap.py
@@ -42,7 +42,7 @@ def template_json(keyboard):
     template_file = Path('keyboards/%s/templates/keymap.json' % keyboard)
     template = {'keyboard': keyboard}
     if template_file.exists():
-        template.update(json.loads(template_file.read_text()))
+        template.update(json.load(template_file.open(encoding='utf-8')))
 
     return template
 
@@ -58,7 +58,7 @@ def template_c(keyboard):
     """
     template_file = Path('keyboards/%s/templates/keymap.c' % keyboard)
     if template_file.exists():
-        template = template_file.read_text()
+        template = template_file.read_text(encoding='utf-8')
     else:
         template = DEFAULT_KEYMAP_C
 
@@ -469,7 +469,7 @@ def parse_keymap_c(keymap_file, use_cpp=True):
         if use_cpp:
             keymap_file = _c_preprocess(keymap_file)
         else:
-            keymap_file = keymap_file.read_text()
+            keymap_file = keymap_file.read_text(encoding='utf-8')
 
     keymap = dict()
     keymap['layers'] = _get_layers(keymap_file)
diff --git a/lib/python/qmk/os_helpers/linux/__init__.py b/lib/python/qmk/os_helpers/linux/__init__.py
index 86850bf28..9e73964e4 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")},
@@ -94,7 +95,7 @@ def check_udev_rules():
 
         # Collect all rules from the config files
         for rule_file in udev_rules:
-            for line in rule_file.read_text().split('\n'):
+            for line in rule_file.read_text(encoding='utf-8').split('\n'):
                 line = line.strip()
                 if not line.startswith("#") and len(line):
                     current_rules.add(line)
diff --git a/lib/python/qmk/tests/test_cli_commands.py b/lib/python/qmk/tests/test_cli_commands.py
index f889833d0..82c42a20e 100644
--- a/lib/python/qmk/tests/test_cli_commands.py
+++ b/lib/python/qmk/tests/test_cli_commands.py
@@ -16,7 +16,7 @@ def check_subcommand(command, *args):
 def check_subcommand_stdin(file_to_read, command, *args):
     """Pipe content of a file to a command and return output.
     """
-    with open(file_to_read) as my_file:
+    with open(file_to_read, encoding='utf-8') as my_file:
         cmd = ['bin/qmk', command, *args]
         result = run(cmd, stdin=my_file, stdout=PIPE, stderr=STDOUT, universal_newlines=True)
     return result
@@ -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