17 files changed, 921 insertions, 113 deletions

diff --git a/docs/cli_commands.md b/docs/cli_commands.md
index eff5321bdb..bb0de3c0db 100644
--- a/docs/cli_commands.md
+++ b/docs/cli_commands.md
@@ -6,6 +6,8 @@
 
 This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm>, compile keymaps in the repo, or compile the keyboard in the current working directory.
 
+This command is directory aware. It will automatically fill in KEYBOARD and/or KEYMAP if you are in a keyboard or keymap directory.
+
 **Usage for Configurator Exports**:
 
 ```
@@ -73,8 +75,9 @@ $ qmk compile -kb dz60
 
 ## `qmk flash`
 
-This command is similar to `qmk compile`, but can also target a bootloader. The bootloader is optional, and is set to `:flash` by default.
-To specify a different bootloader, use `-bl <bootloader>`. Visit the [Flashing Firmware](flashing.md) guide for more details of the available bootloaders.
+This command is similar to `qmk compile`, but can also target a bootloader. The bootloader is optional, and is set to `:flash` by default. To specify a different bootloader, use `-bl <bootloader>`. Visit the [Flashing Firmware](flashing.md) guide for more details of the available bootloaders.
+
+This command is directory aware. It will automatically fill in KEYBOARD and/or KEYMAP if you are in a keyboard or keymap directory.
 
 **Usage for Configurator Exports**:
 
@@ -128,6 +131,32 @@ Check your environment and report problems only:
 
     qmk doctor -n
 
+## `qmk info`
+
+Displays information about keyboards and keymaps in QMK. You can use this to get information about a keyboard, show the layouts, display the underlying key matrix, or to pretty-print JSON keymaps.
+
+**Usage**:
+
+```
+qmk info [-f FORMAT] [-m] [-l] [-km KEYMAP] [-kb KEYBOARD]
+```
+
+This command is directory aware. It will automatically fill in KEYBOARD and/or KEYMAP if you are in a keyboard or keymap directory.
+
+**Examples**:
+
+Show basic information for a keyboard:
+
+    qmk info -kb planck/rev5
+
+Show the matrix for a keyboard:
+
+    qmk info -kb ergodox_ez -m
+
+Show a JSON keymap for a keyboard:
+
+    qmk info -kb clueboard/california -km default
+
 ## `qmk json2c`
 
 Creates a keymap.c from a QMK Configurator export.
@@ -152,6 +181,8 @@ qmk list-keyboards
 
 This command lists all the keymaps for a specified keyboard (and revision).
 
+This command is directory aware. It will automatically fill in KEYBOARD if you are in a keyboard directory.
+
 **Usage**:
 
 ```
@@ -162,6 +193,8 @@ qmk list-keymaps -kb planck/ez
 
 This command creates a new keymap based on a keyboard's existing default keymap.
 
+This command is directory aware. It will automatically fill in KEYBOARD and/or KEYMAP if you are in a keyboard or keymap directory.
+
 **Usage**:
 
 ```
diff --git a/lib/python/qmk/c_parse.py b/lib/python/qmk/c_parse.py
new file mode 100644
index 0000000000..e41e271a43
--- /dev/null
+++ b/lib/python/qmk/c_parse.py
@@ -0,0 +1,161 @@
+"""Functions for working with config.h files.
+"""
+from pathlib import Path
+
+from milc import cli
+
+from qmk.comment_remover import comment_remover
+
+default_key_entry = {'x': -1, 'y': 0, 'w': 1}
+
+
+def c_source_files(dir_names):
+    """Returns a list of all *.c, *.h, and *.cpp files for a given list of directories
+
+    Args:
+
+        dir_names
+            List of directories relative to `qmk_firmware`.
+    """
+    files = []
+    for dir in dir_names:
+        files.extend(file for file in Path(dir).glob('**/*') if file.suffix in ['.c', '.h', '.cpp'])
+    return files
+
+
+def find_layouts(file):
+    """Returns list of parsed LAYOUT preprocessor macros found in the supplied include file.
+    """
+    file = Path(file)
+    aliases = {}  # Populated with all `#define`s that aren't functions
+    parsed_layouts = {}
+
+    # Search the file for LAYOUT macros and aliases
+    file_contents = file.read_text()
+    file_contents = comment_remover(file_contents)
+    file_contents = file_contents.replace('\\\n', '')
+
+    for line in file_contents.split('\n'):
+        if line.startswith('#define') and '(' in line and 'LAYOUT' in line:
+            # We've found a LAYOUT macro
+            macro_name, layout, matrix = _parse_layout_macro(line.strip())
+
+            # Reject bad macro names
+            if macro_name.startswith('LAYOUT_kc') or not macro_name.startswith('LAYOUT'):
+                continue
+
+            # Parse the matrix data
+            matrix_locations = _parse_matrix_locations(matrix, file, macro_name)
+
+            # Parse the layout entries into a basic structure
+            default_key_entry['x'] = -1  # Set to -1 so _default_key(key) will increment it to 0
+            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'])
+
+            parsed_layouts[macro_name] = {
+                'key_count': len(parsed_layout),
+                'layout': parsed_layout,
+                'filename': str(file),
+            }
+
+        elif '#define' in line:
+            # Attempt to extract a new layout alias
+            try:
+                _, pp_macro_name, pp_macro_text = line.strip().split(' ', 2)
+                aliases[pp_macro_name] = pp_macro_text
+            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
+
+
+def parse_config_h_file(config_h_file, config_h=None):
+    """Extract defines from a config.h file.
+    """
+    if not config_h:
+        config_h = {}
+
+    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_text.replace('\\\n', '')
+
+        for linenum, line in enumerate(config_h_text.split('\n')):
+            line = line.strip()
+
+            if '//' in line:
+                line = line[:line.index('//')].strip()
+
+            if not line:
+                continue
+
+            line = line.split()
+
+            if line[0] == '#define':
+                if len(line) == 1:
+                    cli.log.error('%s: Incomplete #define! On or around line %s' % (config_h_file, linenum))
+                elif len(line) == 2:
+                    config_h[line[1]] = True
+                else:
+                    config_h[line[1]] = ' '.join(line[2:])
+
+            elif line[0] == '#undef':
+                if len(line) == 2:
+                    if line[1] in config_h:
+                        if config_h[line[1]] is True:
+                            del config_h[line[1]]
+                        else:
+                            config_h[line[1]] = False
+                else:
+                    cli.log.error('%s: Incomplete #undef! On or around line %s' % (config_h_file, linenum))
+
+    return config_h
+
+
+def _default_key(label=None):
+    """Increment x and return a copy of the default_key_entry.
+    """
+    default_key_entry['x'] += 1
+    new_key = default_key_entry.copy()
+
+    if label:
+        new_key['label'] = label
+
+    return new_key
+
+
+def _parse_layout_macro(layout_macro):
+    """Split the LAYOUT macro into its constituent parts
+    """
+    layout_macro = layout_macro.replace('\\', '').replace(' ', '').replace('\t', '').replace('#define', '')
+    macro_name, layout = layout_macro.split('(', 1)
+    layout, matrix = layout.split(')', 1)
+
+    return macro_name, layout, matrix
+
+
+def _parse_matrix_locations(matrix, file, macro_name):
+    """Parse raw matrix data into a dictionary keyed by the LAYOUT identifier.
+    """
+    matrix_locations = {}
+
+    for row_num, row in enumerate(matrix.split('},{')):
+        if row.startswith('LAYOUT'):
+            cli.log.error('%s: %s: Nested layout macro detected. Matrix data not available!', file, macro_name)
+            break
+
+        row = row.replace('{', '').replace('}', '')
+        for col_num, identifier in enumerate(row.split(',')):
+            if identifier != 'KC_NO':
+                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 394a1353bc..47f60c601b 100644
--- a/lib/python/qmk/cli/__init__.py
+++ b/lib/python/qmk/cli/__init__.py
@@ -13,6 +13,7 @@ from . import docs
 from . import doctor
 from . import flash
 from . import hello
+from . import info
 from . import json
 from . import json2c
 from . import list
diff --git a/lib/python/qmk/cli/cformat.py b/lib/python/qmk/cli/cformat.py
index 0cd8b6192a..600161c5c5 100644
--- a/lib/python/qmk/cli/cformat.py
+++ b/lib/python/qmk/cli/cformat.py
@@ -4,7 +4,9 @@ import subprocess
 from shutil import which
 
 from milc import cli
-import qmk.path
+
+from qmk.path import normpath
+from qmk.c_parse import c_source_files
 
 
 def cformat_run(files, all_files):
@@ -45,10 +47,10 @@ def cformat(cli):
     ignores = ['tmk_core/protocol/usb_hid', 'quantum/template']
     # Find the list of files to format
     if cli.args.files:
-        files.extend(qmk.path.normpath(file) for file in cli.args.files)
+        files.extend(normpath(file) for file in cli.args.files)
     # If -a is specified
     elif cli.args.all_files:
-        all_files = qmk.path.c_source_files(core_dirs)
+        all_files = c_source_files(core_dirs)
         # The following statement checks each file to see if the file path is in the ignored directories.
         files.extend(file for file in all_files if not any(i in str(file) for i in ignores))
     # No files specified & no -a flag
@@ -56,7 +58,7 @@ def cformat(cli):
         base_args = ['git', 'diff', '--name-only', cli.args.base_branch]
         out = subprocess.run(base_args + core_dirs, check=True, stdout=subprocess.PIPE)
         changed_files = filter(None, out.stdout.decode('UTF-8').split('\n'))
-        filtered_files = [qmk.path.normpath(file) for file in changed_files if not any(i in file for i in ignores)]
+        filtered_files = [normpath(file) for file in changed_files if not any(i in file for i in ignores)]
         files.extend(file for file in filtered_files if file.exists() and file.suffix in ['.c', '.h', '.cpp'])
 
     # Run clang-format on the files we've found
diff --git a/lib/python/qmk/cli/info.py b/lib/python/qmk/cli/info.py
new file mode 100755
index 0000000000..6977673e29
--- /dev/null
+++ b/lib/python/qmk/cli/info.py
@@ -0,0 +1,141 @@
+"""Keyboard information script.
+
+Compile an info.json for a particular keyboard and pretty-print it.
+"""
+import json
+
+from milc import cli
+
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.keyboard import render_layouts, render_layout
+from qmk.keymap import locate_keymap
+from qmk.info import info_json
+from qmk.path import is_keyboard
+
+ROW_LETTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop'
+COL_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijilmnopqrstuvwxyz'
+
+
+def show_keymap(info_json, title_caps=True):
+    """Render the keymap in ascii art.
+    """
+    keymap_path = locate_keymap(cli.config.info.keyboard, cli.config.info.keymap)
+
+    if keymap_path and keymap_path.suffix == '.json':
+        if title_caps:
+            cli.echo('{fg_blue}Keymap "%s"{fg_reset}:', cli.config.info.keymap)
+        else:
+            cli.echo('{fg_blue}keymap_%s{fg_reset}:', cli.config.info.keymap)
+
+        keymap_data = json.load(keymap_path.open())
+        layout_name = keymap_data['layout']
+
+        for layer_num, layer in enumerate(keymap_data['layers']):
+            if title_caps:
+                cli.echo('{fg_cyan}Layer %s{fg_reset}:', layer_num)
+            else:
+                cli.echo('{fg_cyan}layer_%s{fg_reset}:', layer_num)
+
+            print(render_layout(info_json['layouts'][layout_name]['layout'], layer))
+
+
+def show_layouts(kb_info_json, title_caps=True):
+    """Render the layouts with info.json labels.
+    """
+    for layout_name, layout_art in render_layouts(kb_info_json).items():
+        title = layout_name.title() if title_caps else layout_name
+        cli.echo('{fg_cyan}%s{fg_reset}:', title)
+        print(layout_art)  # Avoid passing dirty data to cli.echo()
+
+
+def show_matrix(info_json, title_caps=True):
+    """Render the layout with matrix labels in ascii art.
+    """
+    for layout_name, layout in info_json['layouts'].items():
+        # Build our label list
+        labels = []
+        for key in layout['layout']:
+            if key['matrix']:
+                row = ROW_LETTERS[key['matrix'][0]]
+                col = COL_LETTERS[key['matrix'][1]]
+
+                labels.append(row + col)
+            else:
+                labels.append('')
+
+        # Print the header
+        if title_caps:
+            cli.echo('{fg_blue}Matrix for "%s"{fg_reset}:', layout_name)
+        else:
+            cli.echo('{fg_blue}matrix_%s{fg_reset}:', layout_name)
+
+        print(render_layout(info_json['layouts'][layout_name]['layout'], labels))
+
+
+@cli.argument('-kb', '--keyboard', help='Keyboard to show info for.')
+@cli.argument('-km', '--keymap', help='Show the layers for a JSON keymap too.')
+@cli.argument('-l', '--layouts', action='store_true', help='Render the layouts.')
+@cli.argument('-m', '--matrix', action='store_true', help='Render the layouts with matrix information.')
+@cli.argument('-f', '--format', default='friendly', arg_only=True, help='Format to display the data in (friendly, text, json) (Default: friendly).')
+@cli.subcommand('Keyboard information.')
+@automagic_keyboard
+@automagic_keymap
+def info(cli):
+    """Compile an info.json for a particular keyboard and pretty-print it.
+    """
+    # Determine our keyboard(s)
+    if not is_keyboard(cli.config.info.keyboard):
+        cli.log.error('Invalid keyboard: %s!', cli.config.info.keyboard)
+        exit(1)
+
+    # Build the info.json file
+    kb_info_json = info_json(cli.config.info.keyboard)
+
+    # Output in the requested format
+    if cli.args.format == 'json':
+        print(json.dumps(kb_info_json))
+        exit()
+
+    if cli.args.format == 'text':
+        for key in sorted(kb_info_json):
+            if key == 'layouts':
+                cli.echo('{fg_blue}layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys())))
+            else:
+                cli.echo('{fg_blue}%s{fg_reset}: %s', key, kb_info_json[key])
+
+        if cli.config.info.layouts:
+            show_layouts(kb_info_json, False)
+
+        if cli.config.info.matrix:
+            show_matrix(kb_info_json, False)
+
+        if cli.config_source.info.keymap and cli.config_source.info.keymap != 'config_file':
+            show_keymap(kb_info_json, False)
+
+    elif cli.args.format == 'friendly':
+        cli.echo('{fg_blue}Keyboard Name{fg_reset}: %s', kb_info_json.get('keyboard_name', 'Unknown'))
+        cli.echo('{fg_blue}Manufacturer{fg_reset}: %s', kb_info_json.get('manufacturer', 'Unknown'))
+        if 'url' in kb_info_json:
+            cli.echo('{fg_blue}Website{fg_reset}: %s', kb_info_json['url'])
+        if kb_info_json.get('maintainer') == 'qmk':
+            cli.echo('{fg_blue}Maintainer{fg_reset}: QMK Community')
+        else:
+            cli.echo('{fg_blue}Maintainer{fg_reset}: %s', kb_info_json.get('maintainer', 'qmk'))
+        cli.echo('{fg_blue}Keyboard Folder{fg_reset}: %s', kb_info_json.get('keyboard_folder', 'Unknown'))
+        cli.echo('{fg_blue}Layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys())))
+        if 'width' in kb_info_json and 'height' in 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 cli.config.info.layouts:
+            show_layouts(kb_info_json, True)
+
+        if cli.config.info.matrix:
+            show_matrix(kb_info_json, True)
+
+        if cli.config_source.info.keymap and cli.config_source.info.keymap != 'config_file':
+            show_keymap(kb_info_json, True)
+
+    else:
+        cli.log.error('Unknown format: %s', cli.args.format)
diff --git a/lib/python/qmk/cli/list/keymaps.py b/lib/python/qmk/cli/list/keymaps.py
index cec9ca0224..b18289eb35 100644
--- a/lib/python/qmk/cli/list/keymaps.py
+++ b/lib/python/qmk/cli/list/keymaps.py
@@ -4,7 +4,7 @@ from milc import cli
 
 import qmk.keymap
 from qmk.decorators import automagic_keyboard
-from qmk.errors import NoSuchKeyboardError
+from qmk.path import is_keyboard
 
 
 @cli.argument("-kb", "--keyboard", help="Specify keyboard name. Example: 1upkeyboards/1up60hse")
@@ -13,13 +13,9 @@ from qmk.errors import NoSuchKeyboardError
 def list_keymaps(cli):
     """List the keymaps for a specific keyboard
     """
-    try:
-        for name in qmk.keymap.list_keymaps(cli.config.list_keymaps.keyboard):
-            # We echo instead of cli.log.info to allow easier piping of this output
-            cli.echo('%s', name)
-    except NoSuchKeyboardError as e:
-        cli.echo("{fg_red}%s: %s", cli.config.list_keymaps.keyboard, e.message)
-    except (FileNotFoundError, PermissionError) as e:
-        cli.echo("{fg_red}%s: %s", cli.config.list_keymaps.keyboard, e)
-    except TypeError:
-        cli.echo("{fg_red}Something went wrong. Did you specify a keyboard?")
+    if not is_keyboard(cli.config.list_keymaps.keyboard):
+        cli.log.error('Keyboard %s does not exist!', cli.config.list_keymaps.keyboard)
+        exit(1)
+
+    for name in qmk.keymap.list_keymaps(cli.config.list_keymaps.keyboard):
+        print(name)
diff --git a/lib/python/qmk/commands.py b/lib/python/qmk/commands.py
index 5d2a03c9a8..5a6e60988a 100644
--- a/lib/python/qmk/commands.py
+++ b/lib/python/qmk/commands.py
@@ -64,6 +64,7 @@ def compile_configurator_json(user_keymap, bootloader=None):
 def parse_configurator_json(configurator_file):
     """Open and parse a configurator json export
     """
+    # FIXME(skullydazed/anyone): Add validation here
     user_keymap = json.load(configurator_file)
 
     return user_keymap
diff --git a/lib/python/qmk/comment_remover.py b/lib/python/qmk/comment_remover.py
new file mode 100644
index 0000000000..45a25257f8
--- /dev/null
+++ b/lib/python/qmk/comment_remover.py
@@ -0,0 +1,20 @@
+"""Removes C/C++ style comments from text.
+
+Gratefully adapted from https://stackoverflow.com/a/241506
+"""
+import re
+
+comment_pattern = re.compile(r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', re.DOTALL | re.MULTILINE)
+
+
+def _comment_stripper(match):
+    """Removes C/C++ style comments from a regex match.
+    """
+    s = match.group(0)
+    return ' ' if s.startswith('/') else s
+
+
+def comment_remover(text):
+    """Remove C/C++ style comments from text.
+    """
+    return re.sub(comment_pattern, _comment_stripper, text)
diff --git a/lib/python/qmk/constants.py b/lib/python/qmk/constants.py
index 3e4709969d..f0d56c4430 100644
--- a/lib/python/qmk/constants.py
+++ b/lib/python/qmk/constants.py
@@ -7,3 +7,9 @@ QMK_FIRMWARE = Path.cwd()
 
 # This is the number of directories under `qmk_firmware/keyboards` that will be traversed. This is currently a limitation of our make system.
 MAX_KEYBOARD_SUBFOLDERS = 5
+
+# Supported processor types
+ARM_PROCESSORS = 'cortex-m0', 'cortex-m0plus', 'cortex-m3', 'cortex-m4', 'MKL26Z64', 'MK20DX128', 'MK20DX256', 'STM32F042', 'STM32F072', 'STM32F103', 'STM32F303'
+AVR_PROCESSORS = 'at90usb1286', 'at90usb646', 'atmega16u2', 'atmega328p', 'atmega32a', 'atmega32u2', 'atmega32u4', None
+ALL_PROCESSORS = ARM_PROCESSORS + AVR_PROCESSORS
+VUSB_PROCESSORS = 'atmega328p', 'atmega32a'
diff --git a/lib/python/qmk/decorators.py b/lib/python/qmk/decorators.py
index 94e14bf375..f8f2facb1c 100644
--- a/lib/python/qmk/decorators.py
+++ b/lib/python/qmk/decorators.py
@@ -5,7 +5,8 @@ from pathlib import Path
 
 from milc import cli
 
-from qmk.path import is_keyboard, is_keymap_dir, under_qmk_firmware
+from qmk.keymap import is_keymap_dir
+from qmk.path import is_keyboard, under_qmk_firmware
 
 
 def automagic_keyboard(func):
@@ -67,18 +68,18 @@ def automagic_keymap(func):
                         while current_path.parent.name != 'keymaps':
                             current_path = current_path.parent
                         cli.config[cli._entrypoint.__name__]['keymap'] = current_path.name
-                        cli.config_source[cli._entrypoint.__name__]['keyboard'] = 'keymap_directory'
+                        cli.config_source[cli._entrypoint.__name__]['keymap'] = 'keymap_directory'
 
                 # If we're in `qmk_firmware/layouts` guess the name from the community keymap they're in
                 elif relative_cwd.parts[0] == 'layouts' and is_keymap_dir(relative_cwd):
                     cli.config[cli._entrypoint.__name__]['keymap'] = relative_cwd.name
-                    cli.config_source[cli._entrypoint.__name__]['keyboard'] = 'layouts_directory'
+                    cli.config_source[cli._entrypoint.__name__]['keymap'] = 'layouts_directory'
 
                 # If we're in `qmk_firmware/users` guess the name from the userspace they're in
                 elif relative_cwd.parts[0] == 'users':
                     # Guess the keymap name based on which userspace they're in
                     cli.config[cli._entrypoint.__name__]['keymap'] = relative_cwd.parts[1]
-                    cli.config_source[cli._entrypoint.__name__]['keyboard'] = 'users_directory'
+                    cli.config_source[cli._entrypoint.__name__]['keymap'] = 'users_directory'
 
         return func(*args, **kwargs)
 
diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py
new file mode 100644
index 0000000000..e1ace5d51b
--- /dev/null
+++ b/lib/python/qmk/info.py
@@ -0,0 +1,249 @@
+"""Functions that help us generate and use info.json files.
+"""
+import json
+from glob import glob
+from pathlib import Path
+
+from milc import cli
+
+from qmk.constants import ARM_PROCESSORS, AVR_PROCESSORS, VUSB_PROCESSORS
+from qmk.c_parse import find_layouts
+from qmk.keyboard import config_h, rules_mk
+from qmk.math import compute
+
+
+def info_json(keyboard):
+    """Generate the info.json data for a specific keyboard.
+    """
+    info_data = {
+        'keyboard_name': str(keyboard),
+        'keyboard_folder': str(keyboard),
+        'layouts': {},
+        'maintainer': 'qmk',
+    }
+
+    for layout_name, layout_json in _find_all_layouts(keyboard).items():
+        if not layout_name.startswith('LAYOUT_kc'):
+            info_data['layouts'][layout_name] = layout_json
+
+    info_data = merge_info_jsons(keyboard, info_data)
+    info_data = _extract_config_h(info_data)
+    info_data = _extract_rules_mk(info_data)
+
+    return info_data
+
+
+def _extract_config_h(info_data):
+    """Pull some keyboard information from existing rules.mk files
+    """
+    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 row_pins:
+        info_data['matrix_pins']['rows'] = row_pins.split(',')
+    if col_pins:
+        info_data['matrix_pins']['cols'] = col_pins.split(',')
+
+    if direct_pins:
+        direct_pin_array = []
+        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)
+
+        info_data['matrix_pins']['direct'] = direct_pin_array
+
+    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'),
+        'description': config_c.get('DESCRIPTION'),
+    }
+
+    return info_data
+
+
+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')
+
+    if mcu in ARM_PROCESSORS:
+        arm_processor_rules(info_data, rules)
+    elif mcu in AVR_PROCESSORS:
+        avr_processor_rules(info_data, rules)
+    else:
+        cli.log.warning("%s: Unknown MCU: %s" % (info_data['keyboard_folder'], mcu))
+        unknown_processor_rules(info_data, rules)
+
+    return info_data
+
+
+def _find_all_layouts(keyboard):
+    """Looks for layout macros associated with this keyboard.
+    """
+    layouts = {}
+    rules = rules_mk(keyboard)
+    keyboard_path = Path(rules.get('DEFAULT_FOLDER', keyboard))
+
+    # Pull in all layouts defined in the standard files
+    current_path = Path('keyboards/')
+    for directory in keyboard_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))
+
+    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.
+        cli.log.warning('%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:
+            cli.log.error('%s: Missing LAYOUT() macro for %s' % (keyboard, ', '.join(supported_layouts)))
+
+    return layouts
+
+
+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 'STM32' in info_data['processor']:
+            info_data['bootloader'] = 'stm32-dfu'
+        elif info_data.get('manufacturer') == 'Input Club':
+            info_data['bootloader'] = 'kiibohd-dfu'
+
+    if 'STM32' in info_data['processor']:
+        info_data['platform'] = 'STM32'
+    elif 'MCU_SERIES' in rules:
+        info_data['platform'] = rules['MCU_SERIES']
+    elif 'ARM_ATSAM' in rules:
+        info_data['platform'] = 'ARM_ATSAM'
+
+    return info_data
+
+
+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'
+
+    # 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'
+
+    return info_data
+
+
+def unknown_processor_rules(info_data, rules):
+    """Setup the default keyboard info for unknown boards.
+    """
+    info_data['bootloader'] = 'unknown'
+    info_data['platform'] = 'unknown'
+    info_data['processor'] = 'unknown'
+    info_data['processor_type'] = 'unknown'
+    info_data['protocol'] = 'unknown'
+
+    return info_data
+
+
+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
+        with info_file.open('r') as info_fd:
+            new_info_data = json.load(info_fd)
+
+        if not isinstance(new_info_data, dict):
+            cli.log.error("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]
+
+        # 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']):
+                        cli.log.error('%s: %s: Number of elements in info.json does not match! info.json:%s != %s:%s', info_data['keyboard_folder'], 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])
+
+    return info_data
+
+
+def find_info_json(keyboard):
+    """Finds all the info.json files associated with a keyboard.
+    """
+    # Find the most specific first
+    base_path = Path('keyboards')
+    keyboard_path = base_path / keyboard
+    keyboard_parent = keyboard_path.parent
+    info_jsons = [keyboard_path / 'info.json']
+
+    # Add DEFAULT_FOLDER before parents, if present
+    rules = rules_mk(keyboard)
+    if 'DEFAULT_FOLDER' in rules:
+        info_jsons.append(Path(rules['DEFAULT_FOLDER']) / 'info.json')
+
+    # Add in parent folders for least specific
+    for _ in range(5):
+        info_jsons.append(keyboard_parent / 'info.json')
+        if keyboard_parent.parent == base_path:
+            break
+        keyboard_parent = keyboard_parent.parent
+
+    # Return a list of the info.json files that actually exist
+    return [info_json for info_json in info_jsons if info_json.exists()]
diff --git a/lib/python/qmk/keyboard.py b/lib/python/qmk/keyboard.py
new file mode 100644
index 0000000000..d1f2a301df
--- /dev/null
+++ b/lib/python/qmk/keyboard.py
@@ -0,0 +1,111 @@
+"""Functions that help us work with keyboards.
+"""
+from array import array
+from math import ceil
+from pathlib import Path
+
+from qmk.c_parse import parse_config_h_file
+from qmk.makefile import parse_rules_mk_file
+
+
+def config_h(keyboard):
+    """Parses all the config.h files for a keyboard.
+
+    Args:
+        keyboard: name of the keyboard
+
+    Returns:
+        a dictionary representing the content of the entire config.h tree for a keyboard
+    """
+    config = {}
+    cur_dir = Path('keyboards')
+    rules = rules_mk(keyboard)
+    keyboard = Path(rules['DEFAULT_FOLDER'] if 'DEFAULT_FOLDER' in rules else keyboard)
+
+    for dir in keyboard.parts:
+        cur_dir = cur_dir / dir
+        config = {**config, **parse_config_h_file(cur_dir / 'config.h')}
+
+    return config
+
+
+def rules_mk(keyboard):
+    """Get a rules.mk for a keyboard</