def test_internal_rules_dont_create_duplicates(self):
from castervoice.lib import utilities
from castervoice.lib.ctrl.rules_config import RulesConfig
from castervoice.rules.core.alphabet_rules import alphabet
# "write" the rules.toml file:
self._setup_rules_config_file(
loadable_true=["Alphabet"],
enabled=["GrammarActivatorRule", "ManualGrammarReloadRule"])
# check that the mock file changes were written
self.assertEqual(
2, len(self._rule_config._config[RulesConfig._ENABLED_ORDERED]))
# initialize the gm
alphabet_rule = alphabet.get_rule()
self._initialize(FullContentSet([alphabet_rule], [], []))
"""
After initialization, there should only be one copy of each of these in rules.toml:
GrammarActivatorRule
ManualGrammarReloadRule
"""
config = utilities.load_toml_file(
TestGrammarManager._MOCK_PATH_RULES_CONFIG)
enabled_ordered = config[RulesConfig._ENABLED_ORDERED]
self.assertEqual(1, enabled_ordered.count("GrammarActivatorRule"))
self.assertEqual(1, enabled_ordered.count("ManualGrammarReloadRule"))
def test_enable_incompatible_rule_knockout_is_saved(self):
from castervoice.lib import utilities
from castervoice.lib.ctrl.rules_config import RulesConfig
from castervoice.rules.ccr.java_rules import java
from castervoice.rules.ccr.python_rules import python
# "write" the rules.toml file:
self._setup_rules_config_file(loadable_true=["Java", "Python"],
enabled=["Java"])
# check that the mock file changes were written
self.assertEqual(
1, len(self._rule_config._config[RulesConfig._ENABLED_ORDERED]))
# initialize the gm
a, b = java.get_rule(), python.get_rule()
self._initialize(FullContentSet([a, b], [], []))
# simulate a spoken "enable" command from the GrammarActivator:
self._gm._change_rule_enabled("Python", True)
# afterwards, the config should have Python enabled but not Java
config = utilities.load_toml_file(
TestGrammarManager._MOCK_PATH_RULES_CONFIG)
self.assertNotIn("Java", config[RulesConfig._ENABLED_ORDERED])
self.assertIn("Python", config[RulesConfig._ENABLED_ORDERED])
def test_enable_rule_causes_a_save(self):
from castervoice.lib import utilities
from castervoice.lib.ctrl.rules_config import RulesConfig
from castervoice.rules.core.alphabet_rules import alphabet
from castervoice.rules.core.punctuation_rules import punctuation
# "write" the rules.toml file:
self._setup_rules_config_file(
loadable_true=["Alphabet", "Punctuation"], enabled=["Alphabet"])
# check that the mock file changes were written
self.assertEqual(
1, len(self._rule_config._config[RulesConfig._ENABLED_ORDERED]))
# initialize the gm
a, b = alphabet.get_rule(), punctuation.get_rule()
self._initialize(FullContentSet([a, b], [], []))
# simulate a spoken "enable" command from the GrammarActivator:
self._gm._change_rule_enabled("Punctuation", True)
# afterwards, the config should have both Alphabet and Punctuation enabled
config = utilities.load_toml_file(
TestGrammarManager._MOCK_PATH_RULES_CONFIG)
self.assertIn("Alphabet", config[RulesConfig._ENABLED_ORDERED])
self.assertIn("Punctuation", config[RulesConfig._ENABLED_ORDERED])
def refresh(self, *args):
'''args: spec, list of lists of strings'''
# get mapping
recorded_macros = utilities.load_toml_file(
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
if len(args) > 0:
recorded_macros[args[0]] = args[1]
utilities.save_toml_file(
recorded_macros,
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
mapping = {}
for spec in recorded_macros:
# Create a copy of the string without Unicode characters.
ascii_str = str(spec)
sequences = recorded_macros[spec]
delay = settings.SETTINGS["miscellaneous"][
"history_playback_delay_secs"]
# It appears that the associative string (ascii_str) must be ascii, but the sequences within Playback must be Unicode.
mapping[ascii_str] = R(
Playback([(sequence, delay) for sequence in sequences]),
rdescript="Recorded Macro: " + ascii_str) * Repeat(extra="n")
mapping["record from history"] = R(Function(self.record_from_history),
rdescript="Record From History")
mapping["delete recorded macros"] = R(
Function(self.delete_recorded_macros),
rdescript="Delete Recorded Macros")
# reload with new mapping
self.reset(mapping)
def refresh(self, *args):
'''args: spec, list of lists of strings'''
# get mapping
recorded_macros = utilities.load_toml_file(
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
if len(args) > 0:
recorded_macros[args[0]] = args[1]
utilities.save_toml_file(
recorded_macros,
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
mapping = {}
for spec in recorded_macros:
sequences = recorded_macros[spec]
delay = settings.SETTINGS["miscellaneous"][
"history_playback_delay_secs"]
play = Playback([(sequence, delay) for sequence in sequences])
command = play * Repeat(
extra="n") if spec.endswith("[times <n>]") else play
mapping[spec] = R(command, rdescript="Recorded Macro: " + spec)
mapping["record from history"] = R(Function(self.record_from_history),
rdescript="Record From History")
mapping["delete recorded macros"] = R(
Function(self.delete_recorded_macros),
rdescript="Delete Recorded Macros")
# reload with new mapping
self.reset(mapping)
def test_knockout_with_companions_saves_correctly(self):
from castervoice.lib import utilities
from castervoice.lib.ctrl.rules_config import RulesConfig
from castervoice.rules.ccr.java_rules import java
from castervoice.rules.ccr.java_rules import java2
from castervoice.rules.ccr.python_rules import python
from castervoice.rules.ccr.python_rules import python2
from castervoice.rules.core.alphabet_rules import alphabet
from castervoice.rules.apps.microsoft_office import outlook
# "write" the companion config file
self._setup_config_file(utilities, ["paths", "COMPANION_CONFIG_PATH"],
TestGrammarManager._MOCK_PATH_COMPANION_CONFIG,
{
"Java": ["JavaNon"],
"Python": ["PythonNon"]
})
# "write" the rules.toml file:
self._setup_rules_config_file(
loadable_true=[
"Alphabet", "OutlookRule", "Java", "JavaNon", "Python",
"PythonNon"
],
enabled=["Alphabet", "OutlookRule", "Java", "JavaNon"])
# check that the mock file changes were written
self.assertEqual(
4, len(self._rule_config._config[RulesConfig._ENABLED_ORDERED]))
# initialize the gm
alphabet_rule, outlook_rule = alphabet.get_rule(), outlook.get_rule()
python_rule, pythonnon_rule = python.get_rule(), python2.get_rule()
java_rule, javanon_rule = java.get_rule(), java2.get_rule()
self._initialize(
FullContentSet([
alphabet_rule, outlook_rule, python_rule, pythonnon_rule,
java_rule, javanon_rule
], [], []))
# simulate a spoken "enable" command from the GrammarActivator:
self._gm._change_rule_enabled("Python", True)
"""
Afterwards, all of the following should be true:
1. Python and PythonNon should each be in rules.toml exactly once
2. Java and JavaNon should be in rules.toml zero times
3. Alphabet and Outlook should still be in rules.toml
"""
config = utilities.load_toml_file(
TestGrammarManager._MOCK_PATH_RULES_CONFIG)
enabled_ordered = config[RulesConfig._ENABLED_ORDERED]
self.assertEqual(1, enabled_ordered.count("Python"))
self.assertEqual(1, enabled_ordered.count("PythonNon"))
self.assertEqual(0, enabled_ordered.count("Java"))
self.assertEqual(0, enabled_ordered.count("JavaNon"))
self.assertEqual(1, enabled_ordered.count("Alphabet"))
self.assertEqual(1, enabled_ordered.count("OutlookRule"))
def load_config(self):
if self.use_real_config:
self._config = utilities.load_toml_file(
settings.SETTINGS["paths"]["CCR_CONFIG_PATH"])
else:
self._config = {}
def github_checkoutupdate_pull_request(new):
# Function to fetch a PR
try:
Key("c-l/20").execute()
url = read_selected_without_altering_clipboard()
if url[0] == 0:
split_string = url[1].split("/pull/")
repo_url = split_string[0]
pr_name = split_string[1].split("/")[0]
CONFIG = load_toml_file(
settings.SETTINGS["paths"]["GIT_REPO_LOCAL_REMOTE_PATH"])
if not CONFIG:
# logger.warn("Could not load bringme defaults")
raise Exception(
"Could not load " +
settings.SETTINGS["paths"]["GIT_REPO_LOCAL_REMOTE_PATH"])
items = rebuild_local_remote_items(CONFIG)
if repo_url in items:
local_directory = items[repo_url][0]
local_directory = local_directory.replace("\\", "\\\\")
directory_command = "cd " + local_directory
TERMINAL_PATH = settings.SETTINGS["paths"]["TERMINAL_PATH"]
AHK_PATH = settings.SETTINGS["paths"]["AHK_PATH"]
ahk_installed = os.path.isfile(AHK_PATH)
print "AHK_PATH = " + AHK_PATH
if TERMINAL_PATH != "":
load_terminal = True # set default value
# ready fetch command string to be appended to
fetch_command = ""
# find the equivalent ahk script with the same name as this one
ahk_script = __file__.replace(".pyc", ".ahk").replace(
".py", ".ahk")
pattern_match = "MINGW64" # the string we expect to find in the title of git bash when loaded
# if autohotkey is installed
if ahk_installed:
# open the script which checks that git bash window is open or not
p = Popen(
[AHK_PATH, ahk_script, "exists", pattern_match],
stdout=PIPE)
# retrieve the output from the ahk script
stdout, stderr = p.communicate()
# terminates the ahk script if not already done so
p.terminate()
# if an existing git bash window has been activated
if stdout == pattern_match + " activated":
# set the first portion of the fetch command
fetch_command += directory_command + " && "
load_terminal = False
print "Msg:" + ahk_script + " has activated window: " + pattern_match
# if an existing git bash window is not already open
elif stdout == pattern_match + " does not exist":
print "Msg:" + ahk_script + " has found no window: " + pattern_match
print "Load new instance of: " + pattern_match
else:
print "Error:" + ahk_script + " neither returned 'activated' nor 'does not exist'"
print "Fallback: load new instance of :" + pattern_match
if load_terminal:
# open up a new git bash terminal
terminal = Popen(TERMINAL_PATH, cwd=local_directory)
# if autohotkey is installed
if ahk_installed:
# open the script which checks that git bash windoow is ready or not for input
p = Popen([
AHK_PATH, ahk_script, "create", pattern_match
],
stdout=PIPE)
# retrieve the output from the AHK script
stdout, stderr = p.communicate()
# terminates the ahk script if not already done so
p.terminate()
# if the git bash terminal is not ready
if stdout != pattern_match + " ready":
raise Exception(
"Error: git terminal took too long to load for script:"
+ ahk_script)
else: # otherwise await the default number of seconds for the terminal to load
time.sleep(
settings.SETTINGS["gitbash"]["loading_time"])
else:
# Remove any text that's there in the existing terminal
Key("end/10, c-u/10").execute()
# adds to the fetch command string that which will fetch from the particular repository in question
fetch_command += "git fetch " + repo_url + ".git pull/" + pr_name + "/head"
# if fetching from a new pull request
if new:
branch_name_base = repo_url.replace(
"https://github.com/", "")
checkout_command = "git checkout -b " + branch_name_base + "/pull/" + pr_name + " FETCH_HEAD"
# type in the full command into the git bash window
Text(fetch_command + " && " +
checkout_command).execute()
else: # otherwise if it is an update to an existing pull request
branch_name_base = repo_url.replace(
"https://github.com/", "")
checkout_command = "git checkout " + branch_name_base + "/pull/" + pr_name
# type in the full command into the git bash window
Text(fetch_command + " && " +
checkout_command).execute()
Key("enter").execute(
) # checkout is safe enough so will run this
merge_command = "git merge FETCH_HEAD"
# allow time for the fetch commands complete before typing in the next one
time.sleep(
settings.SETTINGS["gitbash"]["fetching_time"])
Text(merge_command).execute()
else:
raise Exception(
'TERMINAL_PATH in <user_dir>/.caster/data/settings.toml is not set'
)
else:
raise Exception(
"Repository URL: " + repo_url + " not found in " +
settings.SETTINGS["paths"]["GIT_REPO_LOCAL_REMOTE_PATH"])
except Exception as e:
print(e)
def load(self):
self._config = utilities.load_toml_file(self._config_path)
