def test_CommandController_load_options(): def test(hist, expect): with replace_history() as history: ctl = FakeController() eq_(ctl.history, history) if hist: history.append(hist) ctl.load_options() eq_(ctl.options.__dict__["_target"], expect) yield test, None, Options(value=None) yield test, "123", Options(value=123)
def test_save_options(): def test(options, hist, command=dummy_command): with replace_history() as history: mod.save_options(options, command, history) eq_(next(iter(history), None), hist) yield test, Options(value=123), "123" yield test, Options(value=None), "abc" @mod.command(arg_parser=CommandParser(Int("value", default=42))) def xyz(textview, sender, options): pass yield test, Options(value=345), "xyz 345", xyz yield test, Options(value=42), "xyz", xyz
def test_TextCommandController_lookup_full_command(): def test(c): m = Mocker() menu = m.mock(ak.NSMenu) ctl = TextCommandController("<history>") for command in c.commands: ctl.add_command(command, None, menu) menu.insertItem_atIndex_(ANY, ANY) eq_(ctl.lookup_full_command(c.lookup), c.result) @command(name="cm") def cmd(*args): pass @command(arg_parser=CommandParser(Int("value")), lookup_with_arg_parser=True) def num(*args): pass c = TestConfig(commands=[], lookup='cmd', result=(None, None)) yield test, c yield test, c(commands=[cmd]) yield test, c(commands=[num]) yield test, c(commands=[num], lookup='123', result=(num, Options(value=123)))
def test_CommandController_save_options(): with replace_history() as history: eq_(next(iter(history), None), None) slc = FakeController() slc.options = Options(value=42) slc.save_options() eq_(next(iter(history)), "42")
def check(err): eq_( str(err), "invalid arguments: num x\n" "invalid literal for int() with base 10: 'x'") eq_(err.options, Options(var=None)) eq_(err.errors, [ ParseError("invalid literal for int() with base 10: 'x'", Int("num"), 4, 5) ])
def test_SubParser(): sub = SubArgs("val", Int("num"), abc="xyz") su2 = SubArgs("str", Choice(('yes', True), ('no', False)), abc="mno") su3 = SubArgs("stx", VarArgs("args", placeholder="..."), abc="pqr") arg = SubParser("var", sub, su2, su3) eq_(str(arg), 'var') eq_( repr(arg), "SubParser('var', SubArgs('val', Int('num'), abc='xyz'), " "SubArgs('str', Choice(('yes', True), ('no', False)), abc='mno'), " "SubArgs('stx', VarArgs('args', placeholder='...'), abc='pqr'))") test = make_completions_checker(arg) yield test, "", (["str", "stx", "val"], 0) yield test, "v", (["val"], 1) yield test, "v ", ([], 2) yield test, "val", (["val"], 3) yield test, "val ", ([], 4) yield test, "val v", (None, 4) yield test, "st", (["str", "stx"], 2) yield test, "str ", (["yes", "no"], 4) yield test, "str y", (["yes"], 5) test = make_placeholder_checker(arg) yield test, "", 0, ("var ...", 0) yield test, "v", 0, ("al num", 1) yield test, "v ", 0, ("num", 2) yield test, "val", 0, (" num", 3) yield test, "val ", 0, ("num", 4) yield test, "val 1", 0, ("", 5) yield test, "val x", 0, (None, None) yield test, "s", 0, ("...", 1) yield test, "s ", 0, (None, None) yield test, "st", 0, ("...", 2) yield test, "str", 0, (" yes", 3) yield test, "str ", 0, ("yes", 4) yield test, "str y", 0, ("es", 5) yield test, "str yes", 0, ("", 7) yield test, "str n", 0, ("o", 5) yield test, "str x", 0, (None, None) yield test, "str x ", 0, (None, None) test = make_type_checker(arg) yield test, '', 0, (None, 0) yield test, 'x', 0, ParseError("'x' does not match any of: str, stx, val", arg, 0, 1) yield test, 'v 1', 0, ((sub, Options(num=1)), 3) yield test, 'val 1', 0, ((sub, Options(num=1)), 5) yield test, 'val 1 2', 0, ((sub, Options(num=1)), 6) yield test, 'val x 2', 0, ArgumentError( "invalid arguments: val x 2", Options(num=None), [ ParseError("invalid literal for int() with base 10: 'x'", Int("num"), 4, 6) ], 4) test = make_arg_string_checker(arg) yield test, (sub, Options(num=1)), "val 1" yield test, (su2, Options(yes=True)), "str " yield test, (su2, Options(yes=False)), "str no"
def test_command_decorator_with_args(): cmd = dummy_command assert cmd.is_text_command eq_(cmd.title, 'Title') eq_(cmd.hotkey, (',', 0)) eq_(cmd.name, 'abc') eq_(cmd.is_enabled(None, None), False) with assert_raises(ArgumentError): cmd.arg_parser.parse('abc def') eq_(cmd.arg_parser.parse('42'), Options(value=42)) eq_(cmd.lookup_with_arg_parser, True)
def test_command_decorator_defaults(): @mod.command def cmd(textview, sender, args): pass assert cmd.is_text_command eq_(cmd.title, None) eq_(cmd.hotkey, None) eq_(cmd.name, 'cmd') eq_(cmd.is_enabled(None, None), True) eq_(cmd.arg_parser.parse('abc def'), Options(args=['abc', 'def'])) eq_(cmd.lookup_with_arg_parser, False)
def test_CommandParser_order(): def test(text, result): if isinstance(result, Options): eq_(parser.parse(text), result) else: assert_raises(result, parser.parse, text) parser = CommandParser( Choice(('selection', True), ('all', False)), Choice(('forward', False), ('reverse', True), name='reverse'), ) tt = Options(selection=True, reverse=True) yield test, 'selection reverse', tt yield test, 'sel rev', tt yield test, 'rev sel', ArgumentError yield test, 'r s', ArgumentError yield test, 's r', tt yield test, 'rev', tt yield test, 'sel', Options(selection=True, reverse=False) yield test, 'r', tt yield test, 's', Options(selection=True, reverse=False)
class WrapLinesController(SheetController): """Window controller for sort lines text command""" COMMAND = wrap_lines NIB_NAME = "WrapLines" OPTIONS_FACTORY = lambda self: Options( wrap_column=const.DEFAULT_RIGHT_MARGIN, indent=True, ) @objc_delegate def wrap_(self, sender): wrap_selected_lines(self.textview, self.options) self.save_options() self.cancel_(sender)
def test_CommandParser_arg_string(): parser = CommandParser(yesno, Choice('arg', 'all')) def test(options, argstr): if isinstance(argstr, Exception): def check(err): eq_(err, argstr) with assert_raises(type(argstr), msg=check): parser.arg_string(options) else: result = parser.arg_string(options) eq_(result, argstr) yield test, Options(yes=True, arg="arg"), "" yield test, Options(yes=False, arg="arg"), "no" yield test, Options(yes=True, arg="all"), " all" yield test, Options(yes=False, arg="all"), "no all" yield test, Options(), Error("missing option: yes") yield test, Options(yes=True), Error("missing option: arg") yield test, Options(yes=None), Error("invalid value: yes=None")
def wrap_at_margin(textview, sender, args): opts = Options() opts.wrap_column = const.DEFAULT_RIGHT_MARGIN opts.indent = args.indent if args is not None else True wrap_selected_lines(textview, opts)
def wrap_at_margin(editor, args): opts = Options() opts.wrap_column = const.DEFAULT_WRAP_COLUMN opts.indent = args.indent if args is not None else True wrap_selected_lines(editor, opts)
def wrap_at_margin(editor, args): opts = Options() opts.wrap_column = const.DEFAULT_RIGHT_MARGIN opts.indent = args.indent if args is not None else True wrap_selected_lines(editor.text_view, opts)
def check(err): eq_(err.options, Options(arg="arg")) eq_(err.errors, [ ParseError("'a' is ambiguous: arg, all", Choice('arg', 'all'), 0, 1) ])
def test_CommandParser_empty(): eq_(arg_parser.parse(''), Options(yes=True))
def test(argstr=None, value=None): with replace_history() as history: if argstr: history.append(argstr) options = mod.load_options(dummy_command, history) eq_(options, Options(value=value))
def test_CommandParser(): def test_parser(argstr, options, parser): if isinstance(options, Exception): def check(err): eq_(err, options) with assert_raises(type(options), msg=check): parser.parse(argstr) else: opts = parser.default_options() opts.__dict__.update(options) eq_(parser.parse(argstr), opts) test = partial(test_parser, parser=CommandParser(yesno)) yield test, "", Options(yes=True) yield test, "no", Options(yes=False) manual = SubArgs("manual", Int("bass", default=50), Int("treble", default=50)) preset = SubArgs("preset", Choice("flat", "rock", "cinema", name="value")) level = Choice(("off", 0), ('high', 4), ("medium", 2), ('low', 1), name="level") radio_parser = CommandParser( SubParser( "equalizer", manual, preset, ), level, Int("volume", default=50), #, min=0, max=100), String("name"), #, quoted=True), ) test = partial(test_parser, parser=radio_parser) yield test, "manual", Options(equalizer=(manual, Options(bass=50, treble=50))) yield test, "", Options() yield test, "preset rock low", Options(level=1, equalizer=(preset, Options(value="rock"))) yield test, " high", Options(level=0, name="high") yield test, " high", Options(level=4) yield test, "high", Options(level=4) yield test, "hi", Options(level=4) yield test, "high '' yes", ArgumentError( 'unexpected argument(s): yes', Options(volume=50, equalizer=None, name='', level=4), [], 8) def test_placeholder(argstr, expected, parser=radio_parser): eq_(parser.get_placeholder(argstr), expected) test = test_placeholder yield test, "", "equalizer ... off 50 name" yield test, " ", "50 name" yield test, " 5", " name" yield test, " 5 ", "name" yield test, " high", "" yield test, " hi", "gh 50 name" yield test, " high", " 50 name" yield test, "hi", "gh 50 name" yield test, "high ", "50 name" def make_completions_checker(argstr, expected, parser=radio_parser): eq_(parser.get_completions(argstr), expected) test = make_completions_checker yield test, "", ['manual', 'preset'] yield test, " ", [] yield test, " 5", [] yield test, " 5 ", [] yield test, " high", [] yield test, " ", ["off", "high", "medium", "low"] yield test, " hi", ["high"] parser = CommandParser(level, Int("value"), Choice("highlander", "tundra", "4runner")) test = partial(make_completions_checker, parser=parser) yield test, "h", ["high"] yield test, "t", ["tundra"] yield test, "high", ["high"] yield test, "high ", [] yield test, "high 4", [] yield test, "high x", None # ??? None indicates an error (the last token could not be consumed) ??? yield test, "high 4", ["4runner"]