def __init__(self, requirements, keywords, name=None): if type(requirements) in (str, unicode): # a string is interpreted to be a mode requirement self.requirements = [ModeRequirement([requirements])] elif type(requirements) in (list,) and all([type(x) in (str, unicode) for x in requirements]): # a list of strings is interpreted to be multiple possible modes self.requirements = [ModeRequirement(requirements)] else: # otherwise we assume we're being passed a real list of requirement objects self.requirements = requirements self.name = name if not self.name: self.name = requirements[0].replace("-", "_") + "_kw_rule" self.keywords = normalizeKeywords(keywords) self.rule = self._buildRule(self.requirements, self.keywords) self.tellEmacs()
from Actions import Key from rules.ContextualRule import makeContextualRule from requirements.Emacs import IsEmacs from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults _mapping = { "external" : Key("ampersand"), } EwwRule = makeContextualRule("Eww", _mapping, emacsExtras, emacsDefaults) EwwRule.context.addRequirement(IsEmacs) EwwRule.context.addRequirement(ModeRequirement(modes="eww-mode"))
def __init__(self, name, cmdWord): WordSelector.__init__(self, name, cmdWord, allowNoChoice=False) self.rule.context.addRequirement(IsEmacs) self.rule.context.addRequirement(ModeRequirement(modes="erc-mode")) getLoop().subscribeEvent(NickEvent, self._onNickList)
"unsetopt", ["/usr/bin/", "user bin"], "up", "valgrind", "wait", ["wc", "word count"], "which", "while", ["xargs", "X args"], ["zsh", "Z shell"], "crontab", "sleep", "time", [">", "stood out"], ["2>", "stood err"], ["&>", "stood both"], ] ShellKeywordRule = KeywordRule(["shell-mode", "sh-mode"], _keywords) _mapping = { "back [<i>]": Key("b,enter") * Repeat(extra="i"), "forward [<i>]": Key("f,enter") * Repeat(extra="i"), "surface [<i>]": (EmacsText("up") + Key("enter")) * Repeat(extra="i"), } ShellRule = makeContextualRule("Shell", _mapping, emacsExtras, emacsDefaults) ShellRule.context.addRequirement(IsEmacs) ShellRule.context.addRequirement( ModeRequirement(modes=["shell-mode", "sh-mode"]))
from Actions import Key from rules.ContextualRule import makeContextualRule from requirements.Emacs import IsEmacs from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults from rules.emacs.Cmd import Cmd from rules.emacs.Text import EmacsText _mapping = { "prior [<i>]": Key("a-p:%(i)d"), "future [<i>]": Key("a-n:%(i)d"), "history": Key("a-r"), "interrupt": Key("c-c,c-c"), "exit": Key("c-d"), "prompt up [<n>]": Key("c-c,c-p:%(n)d"), "prompt down [<n>]": Key("c-c,c-n:%(n)d"), } ComintRule = makeContextualRule("Comint", _mapping, emacsExtras, emacsDefaults) ComintRule.context.addRequirement(IsEmacs) ComintRule.context.addRequirement(ModeRequirement(modes="comint-mode"))
"up", "valgrind", "wait", ["wc", "word count"], "which", "while", ["xargs", "X args"], ["zsh", "Z shell"], "crontab", "sleep", [">", "stood out"], ["2>", "stood err"], ["&>", "stood both"], ] EShellKeywordRule = KeywordRule(["eshell-mode"], _keywords) _mapping = { "back [<i>]": Key("b,enter") * Repeat(extra="i"), "forward [<i>]": Key("f,enter") * Repeat(extra="i"), "surface [<i>]": (EmacsText("up") + Key("enter")) * Repeat(extra="i"), "history": Key("a-r"), "interrupt": Key("c-c,c-c"), "prompt up [<n>]": Key("c-c,c-p:%(n)d"), "prompt down [<n>]": Key("c-c,c-n:%(n)d"), } EShellRule = makeContextualRule("Shell", _mapping, emacsExtras, emacsDefaults) EShellRule.context.addRequirement(IsEmacs) EShellRule.context.addRequirement(ModeRequirement(modes=["eshell-mode"]))
from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults from rules.emacs.Cmd import Cmd from rules.emacs.Keywords import KeywordRule keywords = [ "always", "end", "ifnone", "or", "rpmos", "tranif1", "and", "endcase", "initial", "output", "rtran", "tri", "assign", "endmodule", "inout", "parameter", "rtranif0", "tri0", "begin", "endfunction", "input", "pmos", "rtranif1", "tri1", "buf", "endprimitive", "integer", "posedge", "scalared", "triand", "bufif0", "endspecify", "join", "primitive", "small", "trior", "bufif1", "endtable", "large", "pull0", "specify", "trireg", "case", "endtask", "macromodule", "pull1", "specparam", "vectored", "casex", "event", "medium", "pullup", "strong0", "wait", "casez", "for", "module", "pulldown", "strong1", "wand", "cmos", "force", "nand", "rcmos", "supply0", "weak0", "deassign", "forever", "negedge", "real", "supply1", "weak1", "default", "for", "nmos", "realtime", "table", "while", "defparam", "function", "nor", "reg", "task", "wire", "disable", "highz0", "not", "release", "time", "wor", "edge", "highz1", "notif0", "repeat", "tran", "xnor", "else", "if", "notif1", "rnmos", "tranif0", "xor" ] # VerilogKeywordRule = KeywordRule(["verilog-mode"], keywords) _mapping = {} VerilogRule = makeContextualRule("verilog", _mapping, emacsExtras, emacsDefaults) VerilogRule.context.addRequirement(IsEmacs) VerilogRule.context.addRequirement(ModeRequirement(modes=["verilog-mode"]))
"org list to do" : Key("c-c,a,t"), } OrgAnywhereRule = makeContextualRule("OrgAnywhere", _mapping, emacsExtras, emacsDefaults) OrgAnywhereRule.context.addRequirement(IsEmacs) # "scoot" -> expand section # "cap scoot" -> collapse all sections # "lima" -> log view to see record for the day _mapping = { "new" : Key("a-enter"), "new todo" : Key("as-enter"), "make headline" : Key("c-c,asterisk"), "make table" : Key("c-c,bar"), "archive [<i>]" : Key("c-c,c-t,c-a") * Repeat(extra="i"), "task [<i>]" : Key("c-c,c-x") * Repeat(extra="i"), "follow" : Key("c-c,c-o"), "insert link" : Key("c-c,c-l"), "schedule" : Key("c-c,c-s"), "increase priority [<i>]" : Key("s-up:%(i)d"), "decrease priority [<i>]" : Key("s-down:%(i)d"), "priority one" : Key("c-c,comma,a"), "priority two" : Key("c-c,comma,b"), "priority three" : Key("c-c,comma,c"), } OrgRule = makeContextualRule("Org", _mapping, emacsExtras, emacsDefaults) OrgRule.context.addRequirement(IsEmacs) OrgRule.context.addRequirement(ModeRequirement(modes=["org-mode", "org-agenda-mode"]))
from requirements.Emacs import IsEmacs from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults from rules.emacs.Cmd import Cmd from rules.emacs.Keywords import KeywordRule keywords = [ "abs", "access", "after", "alias", "all", "and", "architecture", "array", "assert", "attribute", "begin", "block", "body", "buffer", "bus", "case", "component", "configuration", "constant", "disconnect", "downto", "else", "elsif", "end", "entity", "exit", "file", "for", "function", "generate", "generic", "group", "guarded", "if", "impure", "in", "inertial", "inout", "is", "label", "library", "linkage", "literal", "loop", "map", "mod", "nand", "new", "next", "nor", "not", "null", "of", "on", "open", "or", "others", "out", "package", "port", "postponed", "procedure", "process", "pure", "range", "record", "register", "reject", "rem", "report", "return", "rol", "ror", "select", "severity", "signal", "shared", "sla", "sll", "sra", "srl", "subtype", "then", "to", "transport", "type", "unaffected", "units", "until", "use", "variable", "wait", "when", "while", "with", "xnor", "xor", ["std_logic", "stood logic"], ["std_logic_vector", "stood logic vector"], "unsigned" ] # VhdlKeywordRule = KeywordRule(["vhdl-mode"], keywords) _mapping = {} VhdlRule = makeContextualRule("vhdl", _mapping, emacsExtras, emacsDefaults) VhdlRule.context.addRequirement(IsEmacs) VhdlRule.context.addRequirement(ModeRequirement(modes=["vhdl-mode"]))
keywords = [ ["SELECT", "select"], ["FROM", "from"], ["ORDER BY", "order by"], ["DESC", "descending"], ["ASC", "ascending"], ["GROUP BY", "group by"], ["LIMIT", "limit"], ["WHERE", "where"], ["JOIN", "join"], ["MERGE", "merge"], ["COUNT", "count"], ["INSERT", "insert"], ["INTO", "INTO"], ["DISTINCT", "distinct"], ] SqlKeywordRule = KeywordRule(["sql-mode", "sql-interactive-mode"], keywords) _mapping = { "history": Key("a-r"), "interrupt": Key("c-c,c-c"), "exit": Key("c-d"), "prompt up [<n>]": Key("c-c,c-p:%(n)d"), "prompt down [<n>]": Key("c-c,c-n:%(n)d"), } SqlRule = makeContextualRule("Sql", _mapping, emacsExtras, emacsDefaults) SqlRule.context.addRequirement(IsEmacs) SqlRule.context.addRequirement(ModeRequirement(modes="sql-interactive-mode"))
"good instruction [<i>]": Key("c-t,c-a,c-i") * Repeat(extra="i"), "good eval": Key("c-t,c-a,c-p"), "good continue": Key("c-t,c-a,c-r"), "good up": Key("c-t,c-a,langle"), "good down": Key("c-t,c-a,rangle"), "good until": Key("c-t,c-a,c-u"), "good finish": Key("c-t,c-a,c-f"), "good jump": Key("c-t,c-a,c-j"), } # TODO: check gdb-running/gdb-stopped variable GnuDebuggerRule = makeContextualRule("GnuDebugger", _mapping, emacsExtras, emacsDefaults) GnuDebuggerRule.context.addRequirement(IsEmacs) GnuDebuggerRule.context.addRequirement( ModeRequirement(modes=["c-mode", "c++-mode"])) keywords = [ "all", "backtrace", "break", "catch", "clear", "commands", "condition", "continue", "delete", "disable", "enable", "finish", "handle",
["cdr", "could-er"], ["let*", "let star"], ["let*-values", "let star values"], ["require/typed", "typed require"], ["set!", "set"], "raise", "String", "unless", ["s-exp", "sexp"], ["#%%module-begin", "module begin"], "this", ] RacketKeywordRule = KeywordRule(["racket-mode", "racket-repl-mode"], keywords) _mapping = { "send buff": Key("c-c,c-c"), "send region": Key("c-c,c-r"), "interpreter": Key("c-c,c-z"), "help racket": Key("c-c,c-d"), "macro expand": Key("c-c,c-e,e"), "macro again": Key("c-c,c-e,a"), "macro region": Key("c-c,c-e,r"), "macro definition": Key("c-c,c-e,x"), } RacketRule = makeContextualRule("Racket", _mapping, emacsExtras, emacsDefaults) RacketRule.context.addRequirement(IsEmacs) RacketRule.context.addRequirement( ModeRequirement(modes=["racket-mode", "racket-repl-mode"]))
from Actions import Key, Text from rules.ContextualRule import makeContextualRule from requirements.Emacs import IsEmacs from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults _mapping = { "dired copy" : Key("c-c,a-w"), "dired cut" : Key("c-c,c-w"), "dired paste" : Key("c-c,c-y") } DiredRule = makeContextualRule("Dired", _mapping, emacsExtras, emacsDefaults) DiredRule.context.addRequirement(IsEmacs) DiredRule.context.addRequirement(ModeRequirement(modes="dired-mode"))
from rules.emacs.Keywords import KeywordRule import keyword _mapping = { "align hash": Cmd("(align-dict)"), "align list": Cmd("(align-list)"), "mark block": Cmd("(er/mark-python-block)"), "mark state": Cmd("(er/mark-python-statement)"), "send funk": Key("ca-x"), "send buff": Key("c-c,c-c"), "send region": Key("c-c,c-r"), "interpreter": Key("c-c,c-z"), } PythonRule = makeContextualRule("Python", _mapping, emacsExtras, emacsDefaults) PythonRule.context.addRequirement(IsEmacs) PythonRule.context.addRequirement( ModeRequirement(modes=["python-mode", "inferior-python-mode"])) keywords = [ "True", "False", "set", "list", "dict", "None", "self", "print", "object", "len", "reversed", "enumerate", "range", ["__init__", "init"], "help", "type", ["__name__", "name"], ["str", "stir"], "unicode", "dir", "all", "any", ["isinstance", "is instance"], ["int", "integer"], "bool", "float", "nonlocal" ] + keyword.kwlist PythonKeywordRule = KeywordRule(["python-mode", "inferior-python-mode"], keywords)
from Actions import Key from rules.ContextualRule import makeContextualRule from requirements.Emacs import IsEmacs from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults # Term mode issues: # -Can wreck prompt and previous output # -Completion won't work, because we need to emulate moving cursor and pressing TAB _mapping = { "line mode": Key("c-c,c-j"), "care mode": Key("c-c,c-k"), } TermRule = makeContextualRule("Term", _mapping, emacsExtras, emacsDefaults) TermRule.context.addRequirement(IsEmacs) TermRule.context.addRequirement(ModeRequirement(modes="term-mode"))
import mdlog log = mdlog.getLogger(__name__) from Actions import Key from rules.ContextualRule import makeContextualRule from requirements.Emacs import IsEmacs from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults from rules.emacs.Cmd import Cmd from rules.emacs.Text import EmacsText from protocol import RuleType IsErcMode = ModeRequirement(modes="erc-mode") _mapping = { "slash join [<text>]": EmacsText("/join #%(text)s"), "slash me [<text>]": EmacsText("/me %(text)s"), } ERCTextRule = makeContextualRule("ERCText", _mapping, emacsExtras, emacsDefaults, ruleType=RuleType.TERMINAL) ERCTextRule.context.addRequirement(IsEmacs) ERCTextRule.context.addRequirement(IsErcMode) _mapping = { "prior": Key("a-p"), "future": Key("a-n"), "smiley wink": EmacsText(";)"),
from requirements.ModeRequirement import ModeRequirement from rules.emacs.common import emacsExtras, emacsDefaults from rules.emacs.Cmd import Cmd from rules.emacs.Keywords import KeywordRule _mapping = { "send funk": Key("ca-x"), "send buff": Key("c-c,c-c"), "send region": Key("c-c,c-r"), "interpreter": Key("c-c,c-z"), } JuliaRule = makeContextualRule("Julia", _mapping, emacsExtras, emacsDefaults) JuliaRule.context.addRequirement(IsEmacs) JuliaRule.context.addRequirement( ModeRequirement(modes=["julia-mode", "inferior-julia-mode"])) keywords = [ "if", "else", "elseif", "while", "for", "begin", "end", "quote", "try", "catch", "return", "local", "function", "macro", "ccall", "finally", "break", "continue", "global", "where", "module", "using", "import", "export", "const", "let", "do", "in", "baremodule", "importall", "immutable", "type", "bitstype", "abstract", "typealias", "primitive ", "struct", "mutable", "Number", "Real", "BigInt", "Integer", "UInt", "UInt8", "UInt16", "UInt32", "UInt64", "UInt128", "Int", "Int8", "Int16", "Int32", "Int64", "Int128", "BigFloat", "AbstractFloat", "Float16", "Float32", "Float64", "Complex128", "Complex64", "Bool", "Cuchar", "Cshort", "Cushort", "Cint", "Cuint", "Clonglong", "Culonglong", "Cintmax_t", "Cuintmax_t", "Cfloat", "Cdouble", "Cptrdiff_t", "Cssize_t", "Csize_t", "Cchar", "Clong", "Culong", "Cwchar_t", "Char", "String", "SubString", "Array", "DArray", "AbstractArray", "AbstractVector",