Sublime snippets first part

castervoice/lib/config/config_toml.py

@@ -5,11 +5,15 @@
 class TomlConfig(BaseConfig):
 
     def __init__(self, config_path):
-        super(TomlConfig, self)
+        super(TomlConfig, self).__init__()
         self._config_path = config_path
 
     def save(self):
+        if not self._config_path:
+            return 
         utilities.save_toml_file(self._config, self._config_path)
 
     def load(self):
+        if not self._config_path:
+            return {}
         self._config = utilities.load_toml_file(self._config_path)

castervoice/rules/apps/editor/sublime.py

@@ -37,9 +37,9 @@ class SublimeRule(MappingRule):
         "(select | sell) all":
             R(Key("c-a")),
         "(select | sell) scope [<n2>]":
-            R(Key("cs-space")),
+            R(Key("cs-space")*Repeat(extra="n2")),
         "(select | sell) brackets [<n2>]":
-            R(Key("cs-m")),
+            R(Key("cs-m")*Repeat(extra="n2")),
         "(select | sell) indent":
             R(Key("cs-j")),
         #
@@ -49,15 +49,21 @@ class SublimeRule(MappingRule):
             R(Key("a-enter")),
         "replace":
             R(Key("c-h")),
+        "replace all":
+            R(Key("ca-enter")),
+        "paste from history":
+            R(Key("c-k,c-v")),
         "edit lines":
             R(Key("cs-l")),
         "edit next [<n3>]":
             R(Key("c-d/10"))*Repeat(extra="n3"),
+        "edit only next [<n3>]":
+            R(Key("c-k,c-d/10"))*Repeat(extra="n3"),
         "edit up [<n3>]":
             R(Key("ac-up"))*Repeat(extra="n3"),
         "edit down [<n3>]":
             R(Key("ac-down"))*Repeat(extra="n3"),
-       "edit all":
+        "edit all":
             R(Key("a-f3")),
         #
         "transform upper":
@@ -69,10 +75,18 @@ class SublimeRule(MappingRule):
             R(Key("c-g/10") + Text("%(ln1)s") + Key("enter")),
         "<action> [line] <ln1> [by <ln2>]":
             R(Function(navigation.action_lines)),
+        "[move] line down [<n3>]":
+            R(Key("cs-down") * Repeat(extra='n3')),
+        "[move] line up [<n3>]":
+            R(Key("cs-up") * Repeat(extra='n3')),
+        #
         "go to file":
             R(Key("c-p")),
         "go to <dict> [<filetype>]":
             R(Key("c-p") + Text("%(dict)s" + "%(filetype)s") + Key("enter")),
+        "file back [<n2>]":
+            R(Key("c-p")  + Key("down")*Repeat(extra="n2") + Key("enter")),
+        #
         "go to word":
             R(Key("c-semicolon")),
         "go to symbol":
@@ -88,6 +102,13 @@ class SublimeRule(MappingRule):
         "command pallette":
             R(Key("cs-p")),
         #
+        "go back [<n2>]":
+            R(Key("a-minus")*Repeat(extra="n2")),
+        "go forward [<n2>]":
+            R(Key("a-plus")*Repeat(extra="n2")),
+        "next modification":R(Key("c-dot")),
+        "previous modification":R(Key("c-comma")),
+        #
         "fold":
             R(Key("cs-lbracket")),
         "unfold":
@@ -103,10 +124,12 @@ class SublimeRule(MappingRule):
             R(Key("c-k, c-b")),
         "show key bindings":
             R(Key("f10, p, right, k")),
+        "show at center":
+            R(Key("c-k,c-c")),
         "zoom in [<n2>]":
-            R(Key("c-equal")),
+            R(Key("c-equal")*Repeat(extra="n2")),
         "zoom out [<n2>]":
-            R(Key("c-minus")),
+            R(Key("c-minus")*Repeat(extra="n2")),
         #
         "(set | add) bookmark":
             R(Key("c-f2")),
@@ -117,8 +140,15 @@ class SublimeRule(MappingRule):
         "clear bookmarks":
             R(Key("cs-f2")),
         #
-        "build it":
-            R(Key("c-b")),
+        "set mark": R(Key("c-k,c-space")),
+        "select mark": R(Key("c-k,c-a")),
+        "swap with mark": R(Key("c-k,c-x")),
+        "delete mark":R(Key("c-k,c-w")),
+        #
+        "build it": R(Key("c-b")),
+        "build with": R(Key("cs-b")),
+        "build <nth>":R(Key("c-s,a-%(nth)s,c-b")),
+        "build [<nth>] last":R(Key("c-s,a-1") + Key("c-pageup")*Repeat(extra="nth") + Key("c-b")),
         #
         "record macro":
             R(Key("c-q")),
@@ -135,15 +165,20 @@ class SublimeRule(MappingRule):
             R(Key("c-pgup")),
         "<nth> tab":
             R(Key("a-%(nth)s")),
+        "[<nth>] last tab":
+            R(Key("a-1") + Key("c-pageup")*Repeat(extra="nth")),
+
         "column <cols>":
             R(Key("as-%(cols)s")),
         "focus <panel>":
             R(Key("c-%(panel)s")),
         "move <panel>":
             R(Key("cs-%(panel)s")),
         #
-        "open terminal":
+        "open terminal": 
             R(Key("cs-t")),
+        "open console":
+            R(Key("c-`")),
     }
     extras = [
         Dictation("dict"),
@@ -188,8 +223,9 @@ class SublimeRule(MappingRule):
         "n2": 1,
         "n3": 1,
         "file type": "",
+        "nth":"1",
     }
 
 
 def get_rule():
-    return SublimeRule, RuleDetails(name="sublime", executable="sublime_text", title="Sublime Text")
+    return SublimeRule, RuleDetails(name="sublime", executable="sublime_text", title="Sublime Text")

castervoice/rules/apps/editor/sublime_rules/Function_like_utilities.py

@@ -0,0 +1,66 @@
+import inspect
+
+import six
+
+############################## UTILITIES TO WRAP FUNCTION CALLS ##############################
+#
+# these functions are based on the dragonfly implementation for Function action, which does not
+# support returning the return value of the function called
+#
+##############################################################################################
+
+
+def get_signature_arguments(function):
+	"""Utility to extract the name of the arguments of the function signature
+
+	Args:
+	    function (Callable): the function in question
+
+	Returns:
+	    Tuple[Set[str],bool]: tuple consistent of
+	    	- the names of the arguments
+	    	- boolean indicating the  function does NOT accept **kwargs
+	"""
+	# pylint: disable=no-member
+	if six.PY2:
+		# pylint: disable=deprecated-method
+		argspec = inspect.getargspec(function)
+	else:
+		argspec = inspect.getfullargspec(function)
+	args, varkw = argspec[0], argspec[2]
+	filter_keywords = not varkw
+	valid_keywords = set(args)
+	return valid_keywords, filter_keywords
+
+
+def get_only_proper_arguments(function,data):
+	valid_keywords, filter_keywords = get_signature_arguments(function)
+	arguments = data.copy()
+	if filter_keywords:
+		invalid_keywords = set(arguments.keys()) - valid_keywords
+		for key in invalid_keywords:
+			del arguments[key]
+	return arguments
+
+def rename_data(data,remap_data):
+	if isinstance(data, dict):
+		renamed = data.copy()
+	else:
+		raise TypeError("evaluate_function received instead of a dictionary " + type(data) + " in data")
+
+	# Remap specified names.
+	for old_name, new_name in remap_data.items():
+		if old_name in data:
+			renamed[new_name] = renamed.pop(old_name)
+	return renamed
+
+
+def evaluate_function(function,data = {},remap_data = {}):
+	renamed = rename_data(data,remap_data)
+	arguments = get_only_proper_arguments(function,renamed)
+	try:
+		return function(**arguments)
+	except Exception as e:
+		raise
+
+