Shortened rule name.

src/rules/__init__.py

@@ -27,7 +27,7 @@ from src.rules.logarithmic import match_constant_logarithm, \
 from src.rules.integrals import match_solve_indef, match_constant_integral, \
         match_integrate_variable_power, match_factor_out_constant, \
         match_division_integral, match_function_integral
-from src.rules.lineq import match_subtract_addition_term
+from src.rules.lineq import match_subtract_term
 
 RULES = {
         OP_ADD: [match_add_numerics, match_add_constant_fractions,
@@ -61,5 +61,5 @@ RULES = {
                  match_factor_out_constant, match_division_integral,
                  match_function_integral],
         OP_INT_INDEF: [match_solve_indef],
-        OP_EQ: [match_subtract_addition_term],
+        OP_EQ: [match_subtract_term],
         }

src/rules/lineq.py

@@ -4,7 +4,7 @@ from ..possibilities import Possibility as P, MESSAGES
 from ..translate import _
 
 
-def match_subtract_addition_term(node):
+def match_subtract_term(node):
     """
     x + a = b   ->  x + a - a = b - a
     x = b + cx  ->  x + - cx = b + cx - cx
@@ -16,25 +16,21 @@ def match_subtract_addition_term(node):
     left, right = node
 
     if left.is_op(OP_ADD):
-        scope = Scope(left)
-
-        for n in scope:
+        for n in Scope(left):
             # Bring terms without x to the right
             if not n.contains(x):
-                p.append(P(node, subtract_addition_term, (n,)))
+                p.append(P(node, subtract_term, (n,)))
 
     if right.is_op(OP_ADD):
-        scope = Scope(right)
-
-        for n in scope:
+        for n in Scope(right):
             # Bring terms with x to the left
             if n.contains(x):
-                p.append(P(node, subtract_addition_term, (n,)))
+                p.append(P(node, subtract_term, (n,)))
 
     return p
 
 
-def subtract_addition_term(root, args):
+def subtract_term(root, args):
     """
     x + a = b   ->  x + a - a = b - a
     x = b + cx  ->  x + - cx = b + cx - cx
@@ -45,5 +41,4 @@ def subtract_addition_term(root, args):
     return eq(left - term, right - term)
 
 
-MESSAGES[subtract_addition_term] = \
-        _('Subtract {1} from both sides of the equation.')
+MESSAGES[subtract_term] = _('Subtract {1} from both sides of the equation.')

tests/test_rules_lineq.py

-from src.rules.lineq import match_subtract_addition_term, \
-        subtract_addition_term
+from src.rules.lineq import match_subtract_term, \
+        subtract_term
 from src.node import Scope
 from src.possibilities import Possibility as P
 from tests.rulestestcase import RulesTestCase, tree
@@ -7,15 +7,15 @@ from tests.rulestestcase import RulesTestCase, tree
 
 class TestRulesLineq(RulesTestCase):
 
-    def test_match_subtract_addition_term(self):
+    def test_match_subtract_term(self):
         root, a = tree('x + a = b, a')
-        self.assertEqualPos(match_subtract_addition_term(root),
-                [P(root, subtract_addition_term, (a,))])
+        self.assertEqualPos(match_subtract_term(root),
+                [P(root, subtract_term, (a,))])
 
         root, cx = tree('x = b + cx, cx')
-        self.assertEqualPos(match_subtract_addition_term(root),
-                [P(root, subtract_addition_term, (cx,))])
+        self.assertEqualPos(match_subtract_term(root),
+                [P(root, subtract_term, (cx,))])
 
-    def test_subtract_addition_term(self):
+    def test_subtract_term(self):
         root, a, expect = tree('x + a = b, a, x + a - a = b - a')
-        self.assertEqual(subtract_addition_term(root, (a,)), expect)
+        self.assertEqual(subtract_term(root, (a,)), expect)