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",
