summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/python/qmk/c_parse.py161
-rw-r--r--lib/python/qmk/cli/__init__.py1
-rw-r--r--lib/python/qmk/cli/cformat.py10
-rwxr-xr-xlib/python/qmk/cli/info.py141
-rw-r--r--lib/python/qmk/cli/list/keymaps.py18
-rw-r--r--lib/python/qmk/commands.py1
-rw-r--r--lib/python/qmk/comment_remover.py20
-rw-r--r--lib/python/qmk/constants.py6
-rw-r--r--lib/python/qmk/decorators.py9
-rw-r--r--lib/python/qmk/info.py249
-rw-r--r--lib/python/qmk/keyboard.py111
-rw-r--r--lib/python/qmk/keymap.py75
-rw-r--r--lib/python/qmk/makefile.py32
-rw-r--r--lib/python/qmk/math.py33
-rw-r--r--lib/python/qmk/path.py26
-rw-r--r--lib/python/qmk/tests/test_cli_commands.py104
16 files changed, 886 insertions, 111 deletions
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
+
+ Args:
+ keyboard: name of the keyboard
+
+ Returns:
+ a dictionary representing the content of the entire rules.mk tree for a keyboard
+ """
+ keyboard = Path(keyboard)
+ cur_dir = Path('keyboards')
+ rules = parse_rules_mk_file(cur_dir / keyboard / 'rules.mk')
+
+ if 'DEFAULT_FOLDER' in rules:
+ keyboard = Path(rules['DEFAULT_FOLDER'])
+
+ for i, dir in enumerate(keyboard.parts):
+ cur_dir = cur_dir / dir
+ rules = parse_rules_mk_file(cur_dir / 'rules.mk', rules)
+
+ return rules
+
+
+def render_layout(layout_data, key_labels=None):
+ """Renders a single layout.
+ """
+ textpad = [array('u', ' ' * 200) for x in range(50)]
+
+ for key in layout_data:
+ x = ceil(key.get('x', 0) * 4)
+ y = ceil(key.get('y', 0) * 3)
+ w = ceil(key.get('w', 1) * 4)
+ h = ceil(key.get('h', 1) * 3)
+
+ if key_labels:
+ label = key_labels.pop(0)
+ if label.startswith('KC_'):
+ label = label[3:]
+ else:
+ label = key.get('label', '')
+
+ label_len = w - 2
+ label_leftover = label_len - len(label)
+
+ if len(label) > label_len:
+ label = label[:label_len]
+
+ label_blank = ' ' * label_len
+ label_border = '─' * label_len
+ label_middle = label + ' '*label_leftover # noqa: yapf insists there be no whitespace around *
+
+ top_line = array('u', '┌' + label_border + '┐')
+ lab_line = array('u', '│' + label_middle + '│')
+ mid_line = array('u', '│' + label_blank + '│')
+ bot_line = array('u', '└' + label_border + "┘")
+
+ textpad[y][x:x + w] = top_line
+ textpad[y + 1][x:x + w] = lab_line
+ for i in range(h - 3):
+ textpad[y + i + 2][x:x + w] = mid_line
+ textpad[y + h - 1][x:x + w] = bot_line
+
+ lines = []
+ for line in textpad:
+ if line.tounicode().strip():
+ lines.append(line.tounicode().rstrip())
+
+ return '\n'.join(lines)
+
+
+def render_layouts(info_json):
+ """Renders all the layouts from an `info_json` structure.
+ """
+ layouts = {}
+
+ for layout in info_json['layouts']:
+ layout_data = info_json['layouts'][layout]['layout']
+ layouts[layout] = render_layout(layout_data)
+
+ return layouts
diff --git a/lib/python/qmk/keymap.py b/lib/python/qmk/keymap.py
index 69cdc8d5b5..70730eb4a8 100644
--- a/lib/python/qmk/keymap.py
+++ b/lib/python/qmk/keymap.py
@@ -2,8 +2,8 @@
"""
from pathlib import Path
-import qmk.path
-import qmk.makefile
+from qmk.path import is_keyboard
+from qmk.keyboard import rules_mk
# The `keymap.c` template to use when a keyboard doesn't have its own
DEFAULT_KEYMAP_C = """#include QMK_KEYBOARD_H
@@ -47,6 +47,14 @@ def _strip_any(keycode):
return keycode
+def is_keymap_dir(keymap):
+ """Return True if Path object `keymap` has a keymap file inside.
+ """
+ for file in ('keymap.c', 'keymap.json'):
+ if (keymap / file).is_file():
+ return True
+
+
def generate(keyboard, layout, layers):
"""Returns a keymap.c for the specified keyboard, layout, and layers.
@@ -95,7 +103,7 @@ def write(keyboard, keymap, layout, layers):
An array of arrays describing the keymap. Each item in the inner array should be a string that is a valid QMK keycode.
"""
keymap_c = generate(keyboard, layout, layers)
- keymap_file = qmk.path.keymap(keyboard) / keymap / 'keymap.c'
+ keymap_file = keymap(keyboard) / keymap / 'keymap.c'
keymap_file.parent.mkdir(parents=True, exist_ok=True)
keymap_file.write_text(keymap_c)
@@ -103,37 +111,76 @@ def write(keyboard, keymap, layout, layers):
return keymap_file
-def list_keymaps(keyboard_name):
+def locate_keymap(keyboard, keymap):
+ """Returns the path to a keymap for a specific keyboard.
+ """
+ if not is_keyboard(keyboard):
+ raise KeyError('Invalid keyboard: ' + repr(keyboard))
+
+ # Check the keyboard folder first, last match wins
+ checked_dirs = ''
+ keymap_path = ''
+
+ for dir in keyboard.split('/'):
+ if checked_dirs:
+ checked_dirs = '/'.join((checked_dirs, dir))
+ else:
+ checked_dirs = dir
+
+ keymap_dir = Path('keyboards') / checked_dirs / 'keymaps'
+
+ if (keymap_dir / keymap / 'keymap.c').exists():
+ keymap_path = keymap_dir / keymap / 'keymap.c'
+ if (keymap_dir / keymap / 'keymap.json').exists():
+ keymap_path = keymap_dir / keymap / 'keymap.json'
+
+ if keymap_path:
+ return keymap_path
+
+ # Check community layouts as a fallback
+ rules = rules_mk(keyboard)
+
+ if "LAYOUTS" in rules:
+ for layout in rules["LAYOUTS"].split():
+ community_layout = Path('layouts/community') / layout / keymap
+ if community_layout.exists():
+ if (community_layout / 'keymap.json').exists():
+ return community_layout / 'keymap.json'
+ if (community_layout / 'keymap.c').exists():
+ return community_layout / 'keymap.c'
+
+
+def list_keymaps(keyboard):
""" List the available keymaps for a keyboard.
Args:
- keyboard_name: the keyboards full name with vendor and revision if necessary, example: clueboard/66/rev3
+ keyboard: the keyboards full name with vendor and revision if necessary, example: clueboard/66/rev3
Returns:
a set with the names of the available keymaps
"""
# parse all the rules.mk files for the keyboard
- rules_mk = qmk.makefile.get_rules_mk(keyboard_name)
+ rules = rules_mk(keyboard)
names = set()
- if rules_mk:
+ if rules:
# qmk_firmware/keyboards
- keyboards_dir = Path.cwd() / "keyboards"
+ keyboards_dir = Path('keyboards')
# path to the keyboard's directory
- kb_path = keyboards_dir / keyboard_name
+ kb_path = keyboards_dir / keyboard
# walk up the directory tree until keyboards_dir
# and collect all directories' name with keymap.c file in it
while kb_path != keyboards_dir:
keymaps_dir = kb_path / "keymaps"
if keymaps_dir.exists():
- names = names.union([keymap for keymap in keymaps_dir.iterdir() if (keymaps_dir / keymap / "keymap.c").is_file()])
+ names = names.union([keymap.name for keymap in keymaps_dir.iterdir() if is_keymap_dir(keymap)])
kb_path = kb_path.parent
# if community layouts are supported, get them
- if "LAYOUTS" in rules_mk:
- for layout in rules_mk["LAYOUTS"].split():
- cl_path = Path.cwd() / "layouts" / "community" / layout
+ if "LAYOUTS" in rules:
+ for layout in rules["LAYOUTS"].split():
+ cl_path = Path('layouts/community') / layout
if cl_path.exists():
- names = names.union([keymap for keymap in cl_path.iterdir() if (cl_path / keymap / "keymap.c").is_file()])
+ names = names.union([keymap.name for keymap in cl_path.iterdir() if is_keymap_dir(keymap)])
return sorted(names)
diff --git a/lib/python/qmk/makefile.py b/lib/python/qmk/makefile.py
index 8645056d2d..02c2e70050 100644
--- a/lib/python/qmk/makefile.py
+++ b/lib/python/qmk/makefile.py
@@ -2,8 +2,6 @@
"""
from pathlib import Path
-from qmk.errors import NoSuchKeyboardError
-
def parse_rules_mk_file(file, rules_mk=None):
"""Turn a rules.mk file into a dictionary.
@@ -51,33 +49,3 @@ def parse_rules_mk_file(file, rules_mk=None):
rules_mk[key.strip()] = value.strip()
return rules_mk
-
-
-def get_rules_mk(keyboard):
- """ Get a rules.mk for a keyboard
-
- Args:
- keyboard: name of the keyboard
-
- Raises:
- NoSuchKeyboardError: when the keyboard does not exists
-
- Returns:
- a dictionary with the content of the rules.mk file
- """
- # Start with qmk_firmware/keyboards
- kb_path = Path.cwd() / "keyboards"
- # walk down the directory tree
- # and collect all rules.mk files
- kb_dir = kb_path / keyboard
- if kb_dir.exists():
- rules_mk = dict()
- for directory in Path(keyboard).parts:
- kb_path = kb_path / directory
- rules_mk_path = kb_path / "rules.mk"
- if rules_mk_path.exists():
- rules_mk = parse_rules_mk_file(rules_mk_path, rules_mk)
- else:
- raise NoSuchKeyboardError("The requested keyboard and/or revision does not exist.")
-
- return rules_mk
diff --git a/lib/python/qmk/math.py b/lib/python/qmk/math.py
new file mode 100644
index 0000000000..88dc4a300c
--- /dev/null
+++ b/lib/python/qmk/math.py
@@ -0,0 +1,33 @@
+"""Parse arbitrary math equations in a safe way.
+
+Gratefully copied from https://stackoverflow.com/a/9558001
+"""
+import ast
+import operator as op
+
+# supported operators
+operators = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul, ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor, ast.USub: op.neg}
+
+
+def compute(expr):
+ """Parse a mathematical expression and return the answer.
+
+ >>> compute('2^6')
+ 4
+ >>> compute('2**6')
+ 64
+ >>> compute('1 + 2*3**(4^5) / (6 + -7)')
+ -5.0
+ """
+ return _eval(ast.parse(expr, mode='eval').body)
+
+
+def _eval(node):
+ if isinstance(node, ast.Num): # <number>
+ return node.n
+ elif isinstance(node, ast.BinOp): # <left> <operator> <right>
+ return operators[type(node.op)](_eval(node.left), _eval(node.right))
+ elif isinstance(node, ast.UnaryOp): # <operator> <operand> e.g., -1
+ return operators[type(node.op)](_eval(node.operand))
+ else:
+ raise TypeError(node)
diff --git a/lib/python/qmk/path.py b/lib/python/qmk/path.py
index 7306c433b8..8df6f0e915 100644
--- a/lib/python/qmk/path.py
+++ b/lib/python/qmk/path.py
@@ -4,20 +4,10 @@ import logging
import os
from pathlib import Path
-from qmk.constants import QMK_FIRMWARE, MAX_KEYBOARD_SUBFOLDERS
+from qmk.constants import MAX_KEYBOARD_SUBFOLDERS, QMK_FIRMWARE
from qmk.errors import NoSuchKeyboardError
-def is_keymap_dir(keymap_path):
- """Returns True if `keymap_path` is a valid keymap directory.
- """
- keymap_path = Path(keymap_path)
- keymap_c = keymap_path / 'keymap.c'
- keymap_json = keymap_path / 'keymap.json'
-
- return any((keymap_c.exists(), keymap_json.exists()))
-
-
def is_keyboard(keyboard_name):
"""Returns True if `keyboard_name` is a keyboard we can compile.
"""
@@ -68,17 +58,3 @@ def normpath(path):
return path
return Path(os.environ['ORIG_CWD']) / path
-
-
-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 pathing starts at qmk's cwd
- """
- files = []
- for dir in dir_names:
- files.extend(file for file in Path(dir).glob('**/*') if file.suffix in ['.c', '.h', '.cpp'])
- return files
diff --git a/lib/python/qmk/tests/test_cli_commands.py b/lib/python/qmk/tests/test_cli_commands.py
index 768929de1d..dce270de83 100644
--- a/lib/python/qmk/tests/test_cli_commands.py
+++ b/lib/python/qmk/tests/test_cli_commands.py
@@ -4,89 +4,151 @@ from qmk.commands import run
def check_subcommand(command, *args):
cmd = ['bin/qmk', command] + list(args)
- return run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+ result = run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
+ return result
+
+
+def check_returncode(result, expected=0):
+ """Print stdout if `result.returncode` does not match `expected`.
+ """
+ if result.returncode != expected:
+ print('`%s` stdout:' % ' '.join(result.args))
+ print(result.stdout)
+ print('returncode:', result.returncode)
+ assert result.returncode == expected
def test_cformat():
result = check_subcommand('cformat', 'quantum/matrix.c')
- assert result.returncode == 0
+ check_returncode(result)
def test_compile():
- assert check_subcommand('compile', '-kb', 'handwired/onekey/pytest', '-km', 'default').returncode == 0
+ result = check_subcommand('compile', '-kb', 'handwired/onekey/pytest', '-km', 'default', '-n')
+ check_returncode(result)
def test_flash():
- assert check_subcommand('flash', '-b').returncode == 1
- assert check_subcommand('flash').returncode == 1
+ result = check_subcommand('flash', '-kb', 'handwired/onekey/pytest', '-km', 'default', '-n')
+ check_returncode(result)
+
+
+def test_flash_bootloaders():
+ result = check_subcommand('flash', '-b')
+ check_returncode(result, 1)
def test_config():
result = check_subcommand('config')
- assert result.returncode == 0
+ check_returncode(result)
assert 'general.color' in result.stdout
def test_kle2json():
- assert check_subcommand('kle2json', 'kle.txt', '-f').returncode == 0
+ result = check_subcommand('kle2json', 'kle.txt', '-f')
+ check_returncode(result)
def test_doctor():
result = check_subcommand('doctor', '-n')
- assert result.returncode == 0
- assert 'QMK Doctor is checking your environment.' in result.stderr
- assert 'QMK is ready to go' in result.stderr
+ check_returncode(result)
+ assert 'QMK Doctor is checking your environment.' in result.stdout
+ assert 'QMK is ready to go' in result.stdout
def test_hello():
result = check_subcommand('hello')
- assert result.returncode == 0
- assert 'Hello,' in result.stderr
+ check_returncode(result)
+ assert 'Hello,' in result.stdout
def test_pyformat():
result = check_subcommand('pyformat')
- assert result.returncode == 0
- assert 'Successfully formatted the python code' in result.stderr
+ check_returncode(result)
+ assert 'Successfully formatted the python code' in result.stdout
+
+
+def test_list_keyboards():
+ result = check_subcommand('list-keyboards')
+ check_returncode(result)
+ # check to see if a known keyboard is returned
+ # this will fail if handwired/onekey/pytest is removed
+ assert 'handwired/onekey/pytest' in result.stdout
def test_list_keymaps():
result = check_subcommand('list-keymaps', '-kb', 'handwired/onekey/pytest')
- assert result.returncode == 0
+ check_returncode(result, 0)
assert 'default' and 'test' in result.stdout
def test_list_keymaps_long():
result = check_subcommand('list-keymaps', '--keyboard', 'handwired/onekey/pytest')
- assert result.returncode == 0
+ check_returncode(result, 0)
assert 'default' and 'test' in result.stdout
def test_list_keymaps_kb_only():
result = check_subcommand('list-keymaps', '-kb', 'niu_mini')
- assert result.returncode == 0
+ check_returncode(result, 0)
assert 'default' and 'via' in result.stdout
def test_list_keymaps_vendor_kb():
result = check_subcommand('list-keymaps', '-kb', 'ai03/lunar')
- assert result.returncode == 0
+ check_returncode(result, 0)
assert 'default' and 'via' in result.stdout
def test_list_keymaps_vendor_kb_rev():
result = check_subcommand('list-keymaps', '-kb', 'kbdfans/kbd67/mkiirgb/v2')
- assert result.returncode == 0
+ check_returncode(result, 0)
assert 'default' and 'via' in result.stdout
def test_list_keymaps_no_keyboard_found():
result = check_subcommand('list-keymaps', '-kb', 'asdfghjkl')
- assert result.returncode == 0
+ check_returncode(result, 1)
assert 'does not exist' in result.stdout
def test_json2c():
result = check_subcommand('json2c', 'keyboards/handwired/onekey/keymaps/default_json/keymap.json')
- assert result.returncode == 0
+ check_returncode(result, 0)
assert result.stdout == '#include QMK_KEYBOARD_H\nconst uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {\t[0] = LAYOUT(KC_A)};\n\n'
+
+
+def test_info():
+ result = check_subcommand('info', '-kb', 'handwired/onekey/pytest')
+ check_returncode(result)
+ assert 'Keyboard Name: handwired/onekey/pytest' in result.stdout
+ assert 'Processor: STM32F303' in result.stdout
+ assert 'Layout:' not in result.stdout
+ assert 'k0' not in result.stdout
+
+
+def test_info_keyboard_render():
+ result = check_subcommand('info', '-kb', 'handwired/onekey/pytest', '-l')
+ check_returncode(result)
+ assert 'Keyboard Name: handwired/onekey/pytest' in result.stdout
+ assert 'Processor: STM32F303' in result.stdout
+ assert 'Layout:' in result.stdout
+ assert 'k0' in result.stdout
+
+
+def test_info_keymap_render():
+ result = check_subcommand('info', '-kb', 'handwired/onekey/pytest', '-km', 'default_json')
+ check_returncode(result)
+ assert 'Keyboard Name: handwired/onekey/pytest' in result.stdout
+ assert 'Processor: STM32F303' in result.stdout
+ assert '│A │' in result.stdout
+
+
+def test_info_matrix_render():
+ result = check_subcommand('info', '-kb', 'handwired/onekey/pytest', '-m')
+ check_returncode(result)
+ assert 'Keyboard Name: handwired/onekey/pytest' in result.stdout
+ assert 'Processor: STM32F303' in result.stdout
+ assert 'LAYOUT' in result.stdout
+ assert '│0A│' in result.stdout
+ assert 'Matrix for "LAYOUT"' in result.stdout
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-23 13:29:36 +0000