Fix typo: Comparsion -> Comparison.

andialbrecht · andialbrecht · commit 09a80107b8f5 · 2010-07-04T21:17:52.000+02:00
diff --git a/docs/source/analyzing.rst b/docs/source/analyzing.rst
@@ -59,6 +59,6 @@ The following classes represent distinct parts of a SQL statement.
 .. autoclass:: sqlparse.sql.Assignment
    :members:
 
-.. autoclass:: sqlparse.sql.Comparsion
+.. autoclass:: sqlparse.sql.Comparison
    :members:
 
diff --git a/sqlparse/engine/grouping.py b/sqlparse/engine/grouping.py
@@ -108,13 +108,13 @@ def group_assignment(tlist):
                       include_semicolon=True)
 
 
-def group_comparsion(tlist):
+def group_comparison(tlist):
 
     def _parts_valid(token):
         return (token.ttype in (T.String.Symbol, T.Name, T.Number,
                                 T.Number.Integer, T.Literal)
                 or isinstance(token, (sql.Identifier,)))
-    _group_left_right(tlist, T.Operator.Comparsion, None, sql.Comparsion,
+    _group_left_right(tlist, T.Operator.Comparison, None, sql.Comparison,
                       check_left=_parts_valid, check_right=_parts_valid)
 
 
@@ -172,7 +172,7 @@ def group_identifier_list(tlist):
                    lambda t: t.match(T.Keyword, 'null'),
                    lambda t: t.ttype == T.Number.Integer,
                    lambda t: t.ttype == T.String.Single,
-                   lambda t: isinstance(t, sql.Comparsion),
+                   lambda t: isinstance(t, sql.Comparison),
                    ]
     tcomma = tlist.token_next_match(idx, T.Punctuation, ',')
     start = None
@@ -298,7 +298,7 @@ def group(tlist):
                  group_as,
                  group_aliased,
                  group_assignment,
-                 group_comparsion,
+                 group_comparison,
                  group_identifier_list,
                  group_if,
                  group_for]:
diff --git a/sqlparse/lexer.py b/sqlparse/lexer.py
@@ -172,7 +172,7 @@ class Lexer:
             (r"`(``|[^`])*`", tokens.Name),
             (r"´(´´|[^´])*´", tokens.Name),
             (r'@[a-zA-Z_][a-zA-Z0-9_]+', tokens.Name),
-            (r'[<>=~!]+', tokens.Operator.Comparsion),
+            (r'[<>=~!]+', tokens.Operator.Comparison),
             (r'[+/@#%^&|`?^-]+', tokens.Operator),
             (r'[0-9]+', tokens.Number.Integer),
             # TODO: Backslash escapes?
diff --git a/sqlparse/sql.py b/sqlparse/sql.py
@@ -59,7 +59,7 @@ def match(self, ttype, values, regex=False):
         type.
         *values* is a list of possible values for this token. The values
         are OR'ed together so if only one of the values matches ``True``
-        is returned. Except for keyword tokens the comparsion is
+        is returned. Except for keyword tokens the comparison is
         case-sensitive. For convenience it's ok to pass in a single string.
         If *regex* is ``True`` (default is ``False``) the given values are
         treated as regular expressions.
@@ -455,8 +455,8 @@ class For(TokenList):
     __slots__ = ('value', 'ttype', 'tokens')
 
 
-class Comparsion(TokenList):
-    """A comparsion used for example in WHERE clauses."""
+class Comparison(TokenList):
+    """A comparison used for example in WHERE clauses."""
     __slots__ = ('value', 'ttype', 'tokens')
 
 
diff --git a/sqlparse/tokens.py b/sqlparse/tokens.py
@@ -58,7 +58,7 @@ def __repr__(self):
 Number = Literal.Number
 Punctuation = Token.Punctuation
 Operator = Token.Operator
-Comparsion = Operator.Comparsion
+Comparison = Operator.Comparison
 Wildcard = Token.Wildcard
 Comment = Token.Comment
 Assignment = Token.Assignement
diff --git a/tests/test_grouping.py b/tests/test_grouping.py
@@ -149,15 +149,15 @@ def test_alias(self):
         self.ndiffAssertEqual(s, p.to_unicode())
         self.assertEqual(p.tokens[4].get_alias(), 'view')
 
-    def test_comparsion_exclude(self):
+    def test_comparison_exclude(self):
         # make sure operators are not handled too lazy
         p = sqlparse.parse('(=)')[0]
         self.assert_(isinstance(p.tokens[0], sql.Parenthesis))
-        self.assert_(not isinstance(p.tokens[0].tokens[1], sql.Comparsion))
+        self.assert_(not isinstance(p.tokens[0].tokens[1], sql.Comparison))
         p = sqlparse.parse('(a=1)')[0]
-        self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparsion))
+        self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparison))
         p = sqlparse.parse('(a>=1)')[0]
-        self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparsion))
+        self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparison))
 
     def test_function(self):
         p = sqlparse.parse('foo()')[0]
