def edit_handler(self): char = self.character target = self.target if self.args: self.msg( "|yYou may specify a description, or use the edit switch, " "but not both.|n") return else: obj = char def load(obj): return obj.db.evmenu_target.db.desc or '' def save(obj, buf): """ Save line buffer to the desc prop. This should return True if successful and also report its status to the user. """ obj.db.evmenu_target.db.desc = buf obj.msg('Saved.') return True def quit(obj): obj.attributes.remove('evmenu_target') obj.msg('Exited editor.') char.db.evmenu_target = target # launch the editor EvEditor(obj, loadfunc=load, savefunc=save, quitfunc=quit, key='desc') return
def func(self): """hook function""" caller = self.caller pycode = self.args if "edit" in self.switches: caller.db._py_measure_time = "time" in self.switches EvEditor(self.caller, loadfunc=_py_load, savefunc=_py_code, quitfunc=_py_quit, key="Python exec: :w or :!", persistent=True, codefunc=_py_code) return if not pycode: string = "Usage: @py <code>" self.msg(string) return _run_code_snippet(caller, self.args, measure_time="time" in self.switches)
def func(self): """hook function""" caller = self.caller pycode = self.args noecho = "noecho" in self.switches if "edit" in self.switches: caller.db._py_measure_time = "time" in self.switches caller.db._py_clientraw = "clientraw" in self.switches EvEditor( self.caller, loadfunc=_py_load, savefunc=_py_code, quitfunc=_py_quit, key="Python exec: :w or :!", persistent=True, codefunc=_py_code, ) return if not pycode: # Run in interactive mode console = EvenniaPythonConsole(self.caller) banner = ( "|gEvennia Interactive Python mode{echomode}\n" "Python {version} on {platform}".format( echomode=" (no echoing of prompts)" if noecho else "", version=sys.version, platform=sys.platform, ) ) self.msg(banner) line = "" main_prompt = "|x[py mode - quit() to exit]|n" prompt = main_prompt while line.lower() not in ("exit", "exit()"): try: line = yield (prompt) if noecho: prompt = "..." if console.push(line) else main_prompt else: prompt = line if console.push(line) else f"{line}\n{main_prompt}" except SystemExit: break self.msg("|gClosing the Python console.|n") return _run_code_snippet( caller, self.args, measure_time="time" in self.switches, client_raw="clientraw" in self.switches, )
def func(self): """Open the line editor to edit the description.""" location = self.caller.location self.caller.db.evmenu_target = self.caller.location # Launch the editor EvEditor(self.caller, loadfunc=_desc_load, savefunc=_desc_save, quitfunc=_desc_quit, key="desc", persistent=True)
def func(self): caller = self.caller opts = self.opts if opts.loc: location = caller.search(opts.loc, global_search=True) if not location: caller.msg("Destination not found.") return else: location = caller.location existing = search_script("EnvScript", obj=location) if opts.type == "init": if len(existing) > 0: caller.msg("An EnvScript already exists.") return script = create_script(EnvScript, obj=location, key="EnvScript") elif len(existing) == 1: script = existing[0] elif len(existing) == 0: caller.msg("No script found.") return else: caller.msg("Error: multiple scripts found.") return if opts.type == "init" or opts.type == "edit": def _env_load(caller): return "\n".join(script.db.messages) def _env_save(caller, buffer): script.db.messages = buffer.splitlines() caller.msg("Messages saved.") return caller.msg("Please place one message on each line.") EvEditor(caller, loadfunc=_env_load, savefunc=_env_save, key="Save messages: :w") if opts.type == "status": caller.msg("The script is operational.") if opts.type == "rm": script.delete() caller.msg("Script deleted.")
def menu_edit(caller, choice, obj): """ Open the EvEditor to edit a specified field. Args: caller (Account or Object): the caller. choice (Choice): the choice object. obj (Object): the object to edit. """ attr = choice.attr caller.db._building_menu_to_edit = (obj, attr) caller.cmdset.remove(BuildingMenuCmdSet) EvEditor(caller, loadfunc=_menu_loadfunc, savefunc=_menu_savefunc, quitfunc=_menu_quitfunc, key="editor", persistent=True)
def func(self): """hook function""" caller = self.caller pycode = self.args if "edit" in self.switches: caller.db._py_measure_time = "time" in self.switches caller.db._py_clientraw = "clientraw" in self.switches EvEditor( self.caller, loadfunc=_py_load, savefunc=_py_code, quitfunc=_py_quit, key="Python exec: :w or :!", persistent=True, codefunc=_py_code, ) return if not pycode: # Run in interactive mode console = EvenniaPythonConsole(self.caller) banner = ( f"|gPython {sys.version} on {sys.platform}\n" "Evennia interactive console mode - type 'exit()' to leave.|n") self.msg(banner) line = "" prompt = ">>>" while line.lower() not in ("exit", "exit()"): line = yield (prompt) prompt = "..." if console.push(line) else ">>>" self.msg("|gClosing the Python console.|n") return _run_code_snippet( caller, self.args, measure_time="time" in self.switches, client_raw="clientraw" in self.switches, )
def add_callback(self): """Add a callback.""" obj = self.obj callback_name = self.callback_name types = self.handler.get_events(obj) # Check that the callback exists if not callback_name.startswith( "chain_") and not callback_name in types: self.msg("The callback name {} can't be found in {} of " \ "typeclass {}.".format(callback_name, obj, type(obj))) return definition = types.get(callback_name, (None, "Chained event.")) description = definition[1] self.msg(raw(description.strip("\n"))) # Open the editor callback = self.handler.add_callback(obj, callback_name, "", self.caller, False, parameters=self.parameters) # Lock this callback right away self.handler.db.locked.append((obj, callback_name, callback["number"])) # Open the editor for this callback self.caller.db._callback = callback EvEditor(self.caller, loadfunc=_ev_load, savefunc=_ev_save, quitfunc=_ev_quit, key="Callback {} of {}".format(callback_name, obj), persistent=True, codefunc=_ev_save)
def func(self): """Implement the function""" switches = self.switches lhslist = self.lhslist if not self.args: self.msg( "Usage: @sethelp[/switches] <topic>[;alias;alias][,category[,locks,..] = <text>" ) return nlist = len(lhslist) topicstr = lhslist[0] if nlist > 0 else "" if not topicstr: self.msg("You have to define a topic!") return topicstrlist = topicstr.split(";") topicstr, aliases = topicstrlist[0], topicstrlist[1:] if len( topicstr) > 1 else [] aliastxt = ("(aliases: %s)" % ", ".join(aliases)) if aliases else "" old_entry = None # check if we have an old entry with the same name try: for querystr in topicstrlist: old_entry = HelpEntry.objects.find_topicmatch( querystr) # also search by alias if old_entry: old_entry = list(old_entry)[0] break category = lhslist[1] if nlist > 1 else old_entry.help_category lockstring = ",".join( lhslist[2:]) if nlist > 2 else old_entry.locks.get() except Exception: old_entry = None category = lhslist[1] if nlist > 1 else "General" lockstring = ",".join(lhslist[2:]) if nlist > 2 else "view:all()" category = category.lower() if 'edit' in switches: # open the line editor to edit the helptext. No = is needed. if old_entry: topicstr = old_entry.key if self.rhs: # we assume append here. old_entry.entrytext += "\n%s" % self.rhs helpentry = old_entry else: helpentry = create.create_help_entry(topicstr, self.rhs, category=category, locks=lockstring, aliases=aliases) self.caller.db._editing_help = helpentry EvEditor(self.caller, loadfunc=_loadhelp, savefunc=_savehelp, quitfunc=_quithelp, key="topic {}".format(topicstr), persistent=True) return if 'append' in switches or "merge" in switches or "extend" in switches: # merge/append operations if not old_entry: self.msg( "Could not find topic '%s'. You must give an exact name." % topicstr) return if not self.rhs: self.msg("You must supply text to append/merge.") return if 'merge' in switches: old_entry.entrytext += " " + self.rhs else: old_entry.entrytext += "\n%s" % self.rhs old_entry.aliases.add(aliases) self.msg("Entry updated:\n%s%s" % (old_entry.entrytext, aliastxt)) return if 'delete' in switches or 'del' in switches: # delete the help entry if not old_entry: self.msg("Could not find topic '%s'%s." % (topicstr, aliastxt)) return old_entry.delete() self.msg("Deleted help entry '%s'%s." % (topicstr, aliastxt)) return # at this point it means we want to add a new help entry. if not self.rhs: self.msg("You must supply a help text to add.") return if old_entry: if 'replace' in switches: # overwrite old entry old_entry.key = topicstr old_entry.entrytext = self.rhs old_entry.help_category = category old_entry.locks.clear() old_entry.locks.add(lockstring) old_entry.aliases.add(aliases) old_entry.save() self.msg("Overwrote the old topic '%s'%s." % (topicstr, aliastxt)) else: self.msg( "Topic '%s'%s already exists. Use /replace to overwrite " "or /append or /merge to add text to it." % (topicstr, aliastxt)) else: # no old entry. Create a new one. new_entry = create.create_help_entry(topicstr, self.rhs, category=category, locks=lockstring, aliases=aliases) if new_entry: self.msg("Topic '%s'%s was successfully created." % (topicstr, aliastxt)) if 'edit' in switches: # open the line editor to edit the helptext self.caller.db._editing_help = new_entry EvEditor(self.caller, loadfunc=_loadhelp, savefunc=_savehelp, quitfunc=_quithelp, key="topic {}".format(new_entry.key), persistent=True) return else: self.msg( "Error when creating topic '%s'%s! Contact an admin." % (topicstr, aliastxt))
def func(self): """ Implements the multidescer. We will use `db.desc` for the description in use and `db.multidesc` to store all descriptions. """ caller = self.caller args = self.args.strip() switches = self.switches try: if "list" in switches or "all" in switches: # list all stored descriptions, either in full or cropped. # Note that we list starting from 1, not from 0. _update_store(caller) do_crop = not "full" in switches if do_crop: outtext = [ "|w%s:|n %s" % (key, crop(desc)) for key, desc in caller.db.multidesc ] else: outtext = [ "\n|w%s:|n|n\n%s\n%s" % (key, "-" * (len(key) + 1), desc) for key, desc in caller.db.multidesc ] caller.msg("|wStored descs:|n\n" + "\n".join(outtext)) return elif "edit" in switches: # Use the eveditor to edit/create the named description if not args: caller.msg("Usage: %s/edit key" % self.key) return # this is used by the editor to know what to edit; it's deleted automatically caller.db._multidesc_editkey = args # start the editor EvEditor(caller, loadfunc=_load_editor, savefunc=_save_editor, quitfunc=_quit_editor, key="multidesc editor", persistent=True) elif "delete" in switches or "del" in switches: # delete a multidesc entry. if not args: caller.msg("Usage: %s/delete key" % self.key) return _update_store(caller, args, delete=True) caller.msg("Deleted description with key '%s'." % args) elif "swap" in switches or "switch" in switches or "reorder" in switches: # Reorder list by swapping two entries. We expect numbers starting from 1 keys = [arg for arg in args.split("-", 1)] if not len(keys) == 2: caller.msg("Usage: %s/swap key1-key2" % self.key) return key1, key2 = keys # perform the swap _update_store(caller, key1, swapkey=key2) caller.msg("Swapped descs '%s' and '%s'." % (key1, key2)) elif "set" in switches: # switches one (or more) of the multidescs to be the "active" description _update_store(caller) if not args: caller.msg("Usage: %s/set key [+ key2 + key3 + ...]" % self.key) return new_desc = [] multidesc = caller.db.multidesc for key in args.split("+"): notfound = True lokey = key.strip().lower() for mkey, desc in multidesc: if lokey == mkey: new_desc.append(desc) notfound = False continue if notfound: # if we get here, there is no desc match, we add it as a normal string new_desc.append(key) new_desc = "".join(new_desc) caller.db.desc = new_desc caller.msg( "%s\n\n|wThe above was set as the current description.|n" % new_desc) elif self.rhs or "add" in switches: # add text directly to a new entry or an existing one. if not (self.lhs and self.rhs): caller.msg("Usage: %s/add key = description" % self.key) return key, desc = self.lhs, self.rhs _update_store(caller, key, desc) caller.msg("Stored description '%s': \"%s\"" % (key, crop(desc))) else: # display the current description or a numbered description _update_store(caller) if args: key = args.lower() multidesc = caller.db.multidesc for mkey, desc in multidesc: if key == mkey: caller.msg("|wDecsription %s:|n\n%s" % (key, desc)) return caller.msg("Description key '%s' not found." % key) else: caller.msg("|wCurrent desc:|n\n%s" % caller.db.desc) except DescValidateError, err: # This is triggered by _key_to_index caller.msg(err)
def edit_callback(self): """Edit a callback.""" obj = self.obj callback_name = self.callback_name parameters = self.parameters callbacks = self.handler.get_callbacks(obj) types = self.handler.get_events(obj) # If no callback name is specified, display the list of callbacks if not callback_name: self.list_callbacks() return # Check that the callback exists if not callback_name in callbacks: self.msg("The callback name {} can't be found in {}.".format( callback_name, obj)) return # If there's only one callback, just edit it if len(callbacks[callback_name]) == 1: number = 0 callback = callbacks[callback_name][0] else: if not parameters: self.msg( "Which callback do you wish to edit? Specify a number.") self.list_callbacks() return # Check that the parameter points to an existing callback try: number = int(parameters) - 1 assert number >= 0 callback = callbacks[callback_name][number] except (ValueError, AssertionError, IndexError): self.msg("The callback {} {} cannot be found in {}.".format( callback_name, parameters, obj)) return # If caller can't edit without validation, forbid editing # others' works if not self.autovalid and callback["author"] is not self.caller: self.msg("You cannot edit this callback created by someone else.") return # If the callback is locked (edited by someone else) if (obj, callback_name, number) in self.handler.db.locked: self.msg("This callback is locked, you cannot edit it.") return self.handler.db.locked.append((obj, callback_name, number)) # Check the definition of the callback definition = types.get(callback_name, (None, "Chained event.")) description = definition[1] self.msg(raw(description.strip("\n"))) # Open the editor callback = dict(callback) self.caller.db._callback = callback EvEditor(self.caller, loadfunc=_ev_load, savefunc=_ev_save, quitfunc=_ev_quit, key="Callback {} of {}".format(callback_name, obj), persistent=True, codefunc=_ev_save)