Merge branch 'ccrmerger2' into myccr

castervoice/lib/alphanumeric.py

@@ -34,6 +34,7 @@ def caster_alphabet():
         "Zulu"    : "z",
     }
 
+
 def get_alphabet_choice(spec):
     return Choice(spec, caster_alphabet())
 

castervoice/lib/ccr/recording/bringme.py

@@ -216,7 +216,7 @@ def _bring_file(self, file):
             "caster bring me": "%USERPROFILE%\\.caster\\data\\sm_bringme.toml",
             "caster ccr": "%USERPROFILE%\\.caster\\data\\ccr.toml",
             "caster config debug": "%USERPROFILE%\\.caster\\data\\configdebug.txt",
-            "caster words": "%USERPROFILE%\\.caster\\filter\\words.txt",
+            "caster words": "%USERPROFILE%\\.caster\\transformers\\words.txt",
             "caster log": "%USERPROFILE%\\.caster\\data\\log.txt",
         }
     }

castervoice/lib/ctrl/nexus.py

@@ -154,7 +154,7 @@ def _create_merger(rules_order_fn, smrc, transformers_runner):
         sorter = ConfigBasedRuleSetSorter(rules_order_fn)
         compat_checker = DetailCompatibilityChecker()
         merge_strategy = ClassicMergingStrategy()
-        max_repetitions = settings.SETTINGS["miscellaneous"]["max_ccr_repetitions"]
+        max_repetitions = settings.settings(["miscellaneous", "max_ccr_repetitions"])
 
         return CCRMerger2(transformers_runner, sorter, compat_checker, merge_strategy, max_repetitions, smrc)
 

castervoice/lib/merge/ccrmerging2/ccrmerger2.py

@@ -96,7 +96,10 @@ def _separate_app_rules(self, compat_results, rcns_to_details):
         return app_crs, non_app_crs
 
     def _create_merged_rules(self, app_crs, non_app_crs):
-        merged_rules = [self._merging_strategy.merge(non_app_crs)]
+        merged_rules = []
+        merged_non_app_crs_rule = self._merging_strategy.merge(non_app_crs)
+        if merged_non_app_crs_rule is not None:
+            merged_rules.append(merged_non_app_crs_rule)
         for app_cr in app_crs:
             with_one_app = list(non_app_crs)
             with_one_app.append(app_cr)
@@ -126,7 +129,8 @@ def _create_contexts(app_crs, rcns_to_details):
                 negation_context = ~context
             else:
                 negation_context += ~context
-        contexts.insert(0, negation_context)
+        if len(contexts) > 0:
+            contexts.insert(0, negation_context)
         return contexts
 
     @staticmethod

castervoice/lib/merge/ccrmerging2/transformers/text_replacer/tr_parser.py

@@ -57,10 +57,9 @@ def _parse_lines(self, lines):
             # extract source and target
             source_and_target = line.split("->")
             source = source_and_target[0].strip()
-            target = source_and_target[1].strip()
-
-            # allow for inline comments
-            target = "#".join(target.split("#")[:1])
+            # allow for inline comments on the right side of the line
+            target = "#".join(source_and_target[1].split("#")[:1])
+            target = target.strip()
 
             """
             See TRParseMode notes for what the different modes mean.

tests/lib/merge/ccrmerging2/test_CCRMerger2.py

@@ -0,0 +1,22 @@
+from unittest import TestCase
+
+from mock import Mock
+
+from castervoice.lib.ctrl.nexus import Nexus
+from castervoice.lib.merge.ccrmerging2.transformers.transformers_runner import TransformersRunner
+
+
+class TestCCRMerger2(TestCase):
+
+    def setUp(self):
+        order_fn = lambda: ["Alphabet", "Numbers"]
+        selfmodrule_configurer = Mock()
+        transformers_config = Mock()
+        transformers_runner = TransformersRunner(transformers_config)
+        self.merger = Nexus._create_merger(order_fn, selfmodrule_configurer, transformers_runner)
+
+    def test_merge_empty(self):
+        """
+        Merger should run through empty list without errors.
+        """
+        self.merger.merge([])

tests/lib/merge/ccrmerging2/transformers/text_replacer/test_TRParser.py

@@ -0,0 +1,67 @@
+from unittest import TestCase
+
+from castervoice.lib.merge.ccrmerging2.transformers.text_replacer.tr_parser import TRParser
+
+
+class TestTRParser(TestCase):
+
+    def test_parse_lines_any(self):
+        """
+        Tests that ANY types make it into their correct categories
+        """
+        parser = TRParser()
+        lines = ["<<<ANY>>>",
+                 "shock -> earthquake"]
+        definitions = parser._parse_lines(lines)
+        self.assertEqual(definitions.specs["shock"], "earthquake")
+        self.assertEqual(1, len(definitions.specs))
+        self.assertEqual(definitions.extras["shock"], "earthquake")
+        self.assertEqual(1, len(definitions.extras))
+        self.assertEqual(definitions.defaults["shock"], "earthquake")
+        self.assertEqual(1, len(definitions.defaults))
+
+    def test_parse_lines_comments(self):
+        """
+        Tests that partially commented lines work and that fully commented lines are excluded
+        """
+        parser = TRParser()
+        lines = ["<<<SPEC>>>",
+                 "#this line -> doesn't get in",
+                 "shock -> earthquake # but this line does"]
+        definitions = parser._parse_lines(lines)
+        self.assertEqual(definitions.specs["shock"], "earthquake")
+        self.assertEqual(1, len(definitions.specs))
+
+    def test_parse_lines(self):
+        """
+        Tests that SPEC, EXTRA, DEFAULT types make it into their correct categories
+        """
+        parser = TRParser()
+        lines = ["<<<SPEC>>>",
+                 "shock -> earthquake",
+                 "<<<EXTRA>>>",
+                 " ",  # blank lines should not cause problems
+                 "goof -> gas",
+                 "<<<DEFAULT>>>",
+                 "some -> none"]
+        definitions = parser._parse_lines(lines)
+        self.assertEqual(definitions.specs["shock"], "earthquake")
+        self.assertEqual(1, len(definitions.specs))
+        self.assertEqual(definitions.extras["goof"], "gas")
+        self.assertEqual(1, len(definitions.extras))
+        self.assertEqual(definitions.defaults["some"], "none")
+        self.assertEqual(1, len(definitions.defaults))
+
+    def test_parse_lines_not_specs(self):
+        """
+        Tests that NOT_SPECS types make it into their correct categories.
+        """
+        parser = TRParser()
+        lines = ["<<<NOT_SPECS>>>",
+                 "aardvark -> beta fish"]
+        definitions = parser._parse_lines(lines)
+        self.assertEqual(0, len(definitions.specs))
+        self.assertEqual(definitions.extras["aardvark"], "beta fish")
+        self.assertEqual(1, len(definitions.extras))
+        self.assertEqual(definitions.defaults["aardvark"], "beta fish")
+        self.assertEqual(1, len(definitions.defaults))

tests/lib/merge/ccrmerging2/transformers/text_replacer/test_textReplacerTransformer.py

@@ -2,6 +2,7 @@
 
 from dragonfly import MappingRule, Dictation, Choice
 
+from castervoice.lib.ccr.core.alphabet import Alphabet
 from castervoice.lib.merge.ccrmerging2.transformers.text_replacer.text_replacer import TextReplacerTransformer
 from castervoice.lib.merge.ccrmerging2.transformers.text_replacer.tr_definitions import TRDefinitions
 from castervoice.lib.merge.mergerule import MergeRule
@@ -69,7 +70,6 @@ def test_replace_mappingrule_spec(self):
         transformed_rule = trt.get_transformed_rule(rule)
 
         self.assertTrue("any <text>" in transformed_rule._mapping.keys())
-        self.assertEqual("_TestMappingRule", transformed_rule.__class__.__name__)
 
     def test_replace_mergerule_spec(self):
         trt = TextReplacerTransformer(_MockTRParser)
@@ -78,4 +78,33 @@ def test_replace_mergerule_spec(self):
         transformed_rule = trt.get_transformed_rule(rule)
 
         self.assertTrue("a few <text>" in transformed_rule._mapping.keys())
-        self.assertEqual("_TestMergeRule", transformed_rule.__class__.__name__)
+
+    def test_replace_mergerule_extra(self):
+        trt = TextReplacerTransformer(_MockTRParser)
+        rule = _TestMergeRule()
+        _MOCK_EXTRAS["element"] = "ornament"
+        transformed_rule = trt.get_transformed_rule(rule)
+
+        self.assertTrue("ornament" in transformed_rule._extras["choice"]._choices)
+        self.assertEqual("e", transformed_rule._extras["choice"]._choices["ornament"])
+
+    def test_replace_real_mergerule_extra(self):
+        trt = TextReplacerTransformer(_MockTRParser)
+        rule = Alphabet()
+        _MOCK_EXTRAS["goof"] = "gas"
+        transformed_rule = trt.get_transformed_rule(rule)
+
+        self.assertTrue("gas" in transformed_rule._extras["letter"]._choices)
+        self.assertEqual("g", transformed_rule._extras["letter"]._choices["gas"])
+
+    def test_that_transformer_does_not_change_class_name(self):
+        trt = TextReplacerTransformer(_MockTRParser)
+        _MOCK_SPECS["some"] = "any"
+
+        rule1 = _TestMappingRule()
+        rule2 = _TestMergeRule()
+
+        transformed_rule1 = trt.get_transformed_rule(rule1)
+        self.assertEqual("_TestMappingRule", transformed_rule1.__class__.__name__)
+        transformed_rule2 = trt.get_transformed_rule(rule2)
+        self.assertEqual("_TestMergeRule", transformed_rule2.__class__.__name__)