Removed deprecated class Upcase and deprecated class keepOriginalText; updated examples to remove those symbols, and to replace operatorPrecedence with infixNotation

git-svn-id: svn://svn.code.sf.net/p/pyparsing/code/trunk@320 9bf210a0-9d2d-494c-87cf-cfb32e7dff7b

13 files changed, 60 insertions, 78 deletions

diff --git a/src/CHANGES b/src/CHANGES
index 21067bf..6f9ea39 100644
--- a/src/CHANGES
+++ b/src/CHANGES
@@ -32,6 +32,13 @@ Version 2.1.0 - February, 2016
 - Cleaned up some examples, fixed typo in fourFn.py identified by

   aristotle2600 on reddit.

 

+- Removed keepOriginalText helper method, which was deprecated ages ago.

+  Superceded by originalTextFor.

+

+- Same for the Upcase class, which was long ago deprecated and replaced

+  with the upcaseTokens method.

+

+

 

 Version 2.0.7 - December, 2015

 ------------------------------

diff --git a/src/examples/eval_arith.py b/src/examples/eval_arith.py
index 85566c7..9562253 100644
--- a/src/examples/eval_arith.py
+++ b/src/examples/eval_arith.py
@@ -9,7 +9,7 @@
 # operands

 #

 from pyparsing import Word, nums, alphas, Combine, oneOf, \

-    opAssoc, operatorPrecedence, Literal

+    opAssoc, infixNotation, Literal

 

 class EvalConstant(object):

     "Class to evaluate a parsed constant or variable"

@@ -120,7 +120,7 @@ expop = Literal('**')
 

 # use parse actions to attach EvalXXX constructors to sub-expressions

 operand.setParseAction(EvalConstant)

-arith_expr = operatorPrecedence(operand,

+arith_expr = infixNotation(operand,

     [

      (signop, 1, opAssoc.RIGHT, EvalSignOp),

      (expop, 2, opAssoc.LEFT, EvalPowerOp),

@@ -129,7 +129,7 @@ arith_expr = operatorPrecedence(operand,
     ])

 

 comparisonop = oneOf("< <= > >= != = <> LT GT LE GE EQ NE")

-comp_expr = operatorPrecedence(arith_expr,

+comp_expr = infixNotation(arith_expr,

     [

     (comparisonop, 2, opAssoc.LEFT, EvalComparisonOp),

     ])

@@ -210,14 +210,14 @@ def main():
     for test,expected in tests:

         ret = comp_expr.parseString(test)[0]

         parsedvalue = ret.eval()

-        print(test, expected, parsedvalue, end=' ')

+        print(test, expected, parsedvalue)

         if parsedvalue != expected:

             print("<<< FAIL")

             failed += 1

         else:

-            print()

+            print('')

             

-    print()

+    print('')

     if failed:

         print(failed, "tests FAILED")

     else:

diff --git a/src/examples/excelExpr.py b/src/examples/excelExpr.py
index 39af365..2700100 100644
--- a/src/examples/excelExpr.py
+++ b/src/examples/excelExpr.py
@@ -6,7 +6,7 @@
 #

 from pyparsing import (CaselessKeyword, Suppress, Word, alphas, 

     alphanums, nums, Optional, Group, oneOf, Forward, Regex, 

-    operatorPrecedence, opAssoc, dblQuotedString, delimitedList, 

+    infixNotation, opAssoc, dblQuotedString, delimitedList, 

     Combine, Literal, QuotedString, ParserElement)

 ParserElement.enablePackrat()

 

@@ -43,14 +43,14 @@ multOp = oneOf("* /")
 addOp = oneOf("+ -")

 numericLiteral = Regex(r"\-?\d+(\.\d+)?")

 operand = numericLiteral | funcCall | cellRange | cellRef 

-arithExpr = operatorPrecedence(operand,

+arithExpr = infixNotation(operand,

     [

     (multOp, 2, opAssoc.LEFT),

     (addOp, 2, opAssoc.LEFT),

     ])

 

 textOperand = dblQuotedString | cellRef

-textExpr = operatorPrecedence(textOperand,

+textExpr = infixNotation(textOperand,

     [

     ('&', 2, opAssoc.LEFT),

     ])

diff --git a/src/examples/idlParse.py b/src/examples/idlParse.py
index 419e56f..dd556e5 100644
--- a/src/examples/idlParse.py
+++ b/src/examples/idlParse.py
@@ -6,7 +6,7 @@
 # Copyright (c) 2003, Paul McGuire

 #

 

-from pyparsing import Literal, CaselessLiteral, Word, Upcase, OneOrMore, ZeroOrMore, \

+from pyparsing import Literal, CaselessLiteral, Word, OneOrMore, ZeroOrMore, \

         Forward, NotAny, delimitedList, oneOf, Group, Optional, Combine, alphas, nums, restOfLine, cStyleComment, \

         alphanums, printables, empty, quotedString, ParseException, ParseResults, Keyword, Regex

 import pprint

diff --git a/src/examples/invRegex.py b/src/examples/invRegex.py
index 26d12ed..5d9a393 100644
--- a/src/examples/invRegex.py
+++ b/src/examples/invRegex.py
@@ -14,7 +14,7 @@
 __all__ = ["count","invert"]

 

 from pyparsing import (Literal, oneOf, printables, ParserElement, Combine, 

-    SkipTo, operatorPrecedence, ParseFatalException, Word, nums, opAssoc,

+    SkipTo, infixNotation, ParseFatalException, Word, nums, opAssoc,

     Suppress, ParseResults, srange)

 

 class CharacterRangeEmitter(object):

@@ -172,7 +172,7 @@ def parser():
         reDot.setParseAction(handleDot)

         

         reTerm = ( reLiteral | reRange | reMacro | reDot | reNonCaptureGroup)

-        reExpr = operatorPrecedence( reTerm,

+        reExpr = infixNotation( reTerm,

             [

             (repetition, 1, opAssoc.LEFT, handleRepetition),

             (None, 2, opAssoc.LEFT, handleSequence),

diff --git a/src/examples/lucene_grammar.py b/src/examples/lucene_grammar.py
index 85e294b..179f25e 100644
--- a/src/examples/lucene_grammar.py
+++ b/src/examples/lucene_grammar.py
@@ -8,7 +8,7 @@
 #

 

 from pyparsing import (Literal, CaselessKeyword, Forward, Regex, QuotedString, Suppress,

-    Optional, Group, FollowedBy, operatorPrecedence, opAssoc, ParseException, ParserElement)

+    Optional, Group, FollowedBy, infixNotation, opAssoc, ParseException, ParserElement)

 ParserElement.enablePackrat()

 

 COLON,LBRACK,RBRACK,LBRACE,RBRACE,TILDE,CARAT = map(Literal,":[]{}~^")

@@ -49,7 +49,7 @@ term << (Optional(field_name("field") + COLON) +
          Optional(boost))

 term.setParseAction(lambda t:[t] if 'field' in t or 'boost' in t else None)

     

-expression << operatorPrecedence(term,

+expression << infixNotation(term,

     [

     (required_modifier | prohibit_modifier, 1, opAssoc.RIGHT),

     ((not_ | '!').setParseAction(lambda:"NOT"), 1, opAssoc.RIGHT),

diff --git a/src/examples/oc.py b/src/examples/oc.py
index 1d49190..77ea195 100644
--- a/src/examples/oc.py
+++ b/src/examples/oc.py
@@ -92,7 +92,7 @@ TYPE = Group((INT | CHAR) + ZeroOrMore("*"))
 

 expr = Forward()

 operand = NAME | integer | char | string_

-expr << (operatorPrecedence(operand, 

+expr << (infixNotation(operand, 

     [

     (oneOf('! - *'), 1, opAssoc.RIGHT),

     (oneOf('++ --'), 1, opAssoc.RIGHT),

diff --git a/src/examples/select_parser.py b/src/examples/select_parser.py
index 677fd11..7c53325 100644
--- a/src/examples/select_parser.py
+++ b/src/examples/select_parser.py
@@ -63,7 +63,7 @@ expr_term = (
     )

 

 UNARY,BINARY,TERNARY=1,2,3

-expr << operatorPrecedence(expr_term,

+expr << infixNotation(expr_term,

     [

     (oneOf('- + ~') | NOT, UNARY, opAssoc.RIGHT),

     (ISNULL | NOTNULL | NOT + NULL, UNARY, opAssoc.LEFT),

diff --git a/src/examples/simpleArith.py b/src/examples/simpleArith.py
index 09c32d3..825956b 100644
--- a/src/examples/simpleArith.py
+++ b/src/examples/simpleArith.py
@@ -2,7 +2,7 @@
 # simpleArith.py

 #

 # Example of defining an arithmetic expression parser using

-# the operatorPrecedence helper method in pyparsing.

+# the infixNotation helper method in pyparsing.

 #

 # Copyright 2006, by Paul McGuire

 #

@@ -19,11 +19,11 @@ multop = oneOf('* /')
 plusop = oneOf('+ -')

 factop = Literal('!')

 

-# To use the operatorPrecedence helper:

+# To use the infixNotation helper:

 #   1.  Define the "atom" operand term of the grammar.

 #       For this simple grammar, the smallest operand is either

 #       and integer or a variable.  This will be the first argument

-#       to the operatorPrecedence method.

+#       to the infixNotation method.

 #   2.  Define a list of tuples for each level of operator

 #       precendence.  Each tuple is of the form

 #       (opExpr, numTerms, rightLeftAssoc, parseAction), where

@@ -37,13 +37,13 @@ factop = Literal('!')
 #       - parseAction is the parse action to be associated with 

 #          expressions matching this operator expression (the

 #          parse action tuple member may be omitted)

-#   3.  Call operatorPrecedence passing the operand expression and

+#   3.  Call infixNotation passing the operand expression and

 #       the operator precedence list, and save the returned value

 #       as the generated pyparsing expression.  You can then use

 #       this expression to parse input strings, or incorporate it

 #       into a larger, more complex grammar.

 #       

-expr = operatorPrecedence( operand,

+expr = infixNotation( operand,

     [("!", 1, opAssoc.LEFT),

      ("^", 2, opAssoc.RIGHT),

      (signop, 1, opAssoc.RIGHT),

@@ -63,5 +63,5 @@ test = ["9 + 2 + 3",
 for t in test:

     print(t)

     print(expr.parseString(t))

-    print() 

+    print('') 

 

diff --git a/src/examples/simpleSQL.py b/src/examples/simpleSQL.py
index 62f9928..e19d5c2 100644
--- a/src/examples/simpleSQL.py
+++ b/src/examples/simpleSQL.py
@@ -5,12 +5,12 @@
 #

 # Copyright (c) 2003, Paul McGuire

 #

-from pyparsing import Literal, CaselessLiteral, Word, Upcase, delimitedList, Optional, \

+from pyparsing import Literal, CaselessLiteral, Word, delimitedList, Optional, \

     Combine, Group, alphas, nums, alphanums, ParseException, Forward, oneOf, quotedString, \

-    ZeroOrMore, restOfLine, Keyword

+    ZeroOrMore, restOfLine, Keyword, upcaseTokens

 

 def test( str ):

-    print(str,"->")

+    print(str + " ->")

     try:

         tokens = simpleSQL.parseString( str )

         print("tokens = ",        tokens)

@@ -18,9 +18,9 @@ def test( str ):
         print("tokens.tables =",  tokens.tables)

         print("tokens.where =", tokens.where)

     except ParseException as err:

-        print(" "*err.loc + "^\n" + err.msg)

+        print(" "*err.loc + "^")

         print(err)

-    print()

+    print('')

 

 

 # define SQL tokens

@@ -29,9 +29,9 @@ selectToken = Keyword("select", caseless=True)
 fromToken   = Keyword("from", caseless=True)

 

 ident          = Word( alphas, alphanums + "_$" ).setName("identifier")

-columnName     = Upcase( delimitedList( ident, ".", combine=True ) )

+columnName     = ( delimitedList( ident, ".", combine=True ) ).addParseAction(upcaseTokens)

 columnNameList = Group( delimitedList( columnName ) )

-tableName      = Upcase( delimitedList( ident, ".", combine=True ) )

+tableName      = ( delimitedList( ident, ".", combine=True ) ).addParseAction(upcaseTokens)

 tableNameList  = Group( delimitedList( tableName ) )

 

 whereExpression = Forward()

diff --git a/src/examples/verilogParse.py b/src/examples/verilogParse.py
index 5eaf14f..2b7fd35 100644
--- a/src/examples/verilogParse.py
+++ b/src/examples/verilogParse.py
@@ -68,7 +68,7 @@ import sys
 

 __version__ = "1.0.11"

 

-from pyparsing import Literal, CaselessLiteral, Keyword, Word, Upcase, OneOrMore, ZeroOrMore, \

+from pyparsing import Literal, CaselessLiteral, Keyword, Word, OneOrMore, ZeroOrMore, \

         Forward, NotAny, delimitedList, Group, Optional, Combine, alphas, nums, restOfLine, cStyleComment, \

         alphanums, printables, dblQuotedString, empty, ParseException, ParseResults, MatchFirst, oneOf, GoToColumn, \

         ParseResults,StringEnd, FollowedBy, ParserElement, And, Regex, cppStyleComment#,__version__

diff --git a/src/pyparsing.py b/src/pyparsing.py
index f9f1774..3139bd9 100644
--- a/src/pyparsing.py
+++ b/src/pyparsing.py
@@ -82,12 +82,12 @@ __all__ = [
 'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',

 'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',

 'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',

-'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 'Upcase',

+'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 

 'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',

 'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',

 'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',

 'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',

-'htmlComment', 'javaStyleComment', 'keepOriginalText', 'line', 'lineEnd', 'lineStart', 'lineno',

+'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',

 'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',

 'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',

 'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 

@@ -3047,17 +3047,6 @@ class TokenConverter(ParseElementEnhance):
         super(TokenConverter,self).__init__( expr )#, savelist )

         self.saveAsList = False

 

-class Upcase(TokenConverter):

-    """Converter to upper case all matching tokens."""

-    def __init__(self, *args):

-        super(Upcase,self).__init__(*args)

-        warnings.warn("Upcase class is deprecated, use upcaseTokens parse action instead",

-                       DeprecationWarning,stacklevel=2)

-

-    def postParse( self, instring, loc, tokenlist ):

-        return list(map( str.upper, tokenlist ))

-

-

 class Combine(TokenConverter):

     """Converter to concatenate all matching tokens to a single string.

        By default, the matching patterns must also be contiguous in the input string;

@@ -3364,9 +3353,7 @@ def originalTextFor(expr, asString=True):
     """Helper to return the original, untokenized text for a given expression.  Useful to

        restore the parsed fields of an HTML start tag into the raw tag text itself, or to

        revert separate tokens with intervening whitespace back to the original matching

-       input text. Simpler to use than the parse action C{L{keepOriginalText}}, and does not

-       require the inspect module to chase up the call stack.  By default, returns a 

-       string containing the original parsed text.  

+       input text. By default, returns astring containing the original parsed text.  

        

        If the optional C{asString} argument is passed as C{False}, then the return value is a 

        C{L{ParseResults}} containing any results names that were originally matched, and a 

@@ -3478,18 +3465,6 @@ def downcaseTokens(s,l,t):
     """Helper parse action to convert tokens to lower case."""

     return [ tt.lower() for tt in map(_ustr,t) ]

 

-def keepOriginalText(s,startLoc,t):

-    """DEPRECATED - use new helper method C{L{originalTextFor}}.

-       Helper parse action to preserve original parsed text,

-       overriding any nested parse actions."""

-    try:

-        endloc = getTokensEndLoc()

-    except ParseException:

-        raise ParseFatalException("incorrect usage of keepOriginalText - may only be called as a parse action")

-    del t[:]

-    t += ParseResults(s[startLoc:endloc])

-    return t

-

 def getTokensEndLoc():

     """Method to be called from within a parse action to determine the end

        location of the parsed tokens."""

diff --git a/src/unitTests.py b/src/unitTests.py
index f38606b..6672b96 100644
--- a/src/unitTests.py
+++ b/src/unitTests.py
@@ -1084,9 +1084,9 @@ class RecursiveCombineTest(ParseTestCase):
         

         assert "".join(testVal) == "".join(expected), "Failed to process Combine with recursive content"

 

-class OperatorPrecedenceGrammarTest1(ParseTestCase):

+class InfixNotationGrammarTest1(ParseTestCase):

     def runTest(self):

-        from pyparsing import Word,nums,alphas,Literal,oneOf,operatorPrecedence,opAssoc

+        from pyparsing import Word,nums,alphas,Literal,oneOf,infixNotation,opAssoc

         

         integer = Word(nums).setParseAction(lambda t:int(t[0]))

         variable = Word(alphas,exact=1)

@@ -1098,7 +1098,7 @@ class OperatorPrecedenceGrammarTest1(ParseTestCase):
         plusop = oneOf('+ -')

         factop = Literal('!')

 

-        expr = operatorPrecedence( operand,

+        expr = infixNotation( operand,

             [("!", 1, opAssoc.LEFT),

              ("^", 2, opAssoc.RIGHT),

              (signop, 1, opAssoc.RIGHT),

@@ -1131,12 +1131,12 @@ class OperatorPrecedenceGrammarTest1(ParseTestCase):
         expected = [eval(x) for x in expected]

         for t,e in zip(test,expected):

             print_(t,"->",e, "got", expr.parseString(t).asList())

-            assert expr.parseString(t).asList() == e,"mismatched results for operatorPrecedence: got %s, expected %s" % (expr.parseString(t).asList(),e)

+            assert expr.parseString(t).asList() == e,"mismatched results for infixNotation: got %s, expected %s" % (expr.parseString(t).asList(),e)

 

-class OperatorPrecedenceGrammarTest2(ParseTestCase):

+class InfixNotationGrammarTest2(ParseTestCase):

     def runTest(self):

 

-        from pyparsing import operatorPrecedence, Word, alphas, oneOf, opAssoc

+        from pyparsing import infixNotation, Word, alphas, oneOf, opAssoc

         

         boolVars = { "True":True, "False":False }

         class BoolOperand(object):

@@ -1183,7 +1183,7 @@ class OperatorPrecedenceGrammarTest2(ParseTestCase):
                 return not v

 

         boolOperand = Word(alphas,max=1) | oneOf("True False")

-        boolExpr = operatorPrecedence( boolOperand,

+        boolExpr = infixNotation( boolOperand,

             [

             ("not", 1, opAssoc.RIGHT, BoolNot),

             ("and", 2, opAssoc.LEFT,  BoolAnd),

@@ -1212,10 +1212,10 @@ class OperatorPrecedenceGrammarTest2(ParseTestCase):
             print_(t,'\n', res, '=', bool(res),'\n')

 

         

-class OperatorPrecedenceGrammarTest3(ParseTestCase):

+class InfixNotationGrammarTest3(ParseTestCase):

     def runTest(self):

 

-        from pyparsing import operatorPrecedence, Word, alphas, oneOf, opAssoc, nums, Literal

+        from pyparsing import infixNotation, Word, alphas, oneOf, opAssoc, nums, Literal

         

         global count

         count = 0

@@ -1237,7 +1237,7 @@ class OperatorPrecedenceGrammarTest3(ParseTestCase):
         plusop = oneOf('+ -')

         factop = Literal('!')

 

-        expr = operatorPrecedence( operand,

+        expr = infixNotation( operand,

             [

             ("!", 1, opAssoc.LEFT),

             ("^", 2, opAssoc.RIGHT),

@@ -1252,7 +1252,7 @@ class OperatorPrecedenceGrammarTest3(ParseTestCase):
             print_("%s => %s" % (t, expr.parseString(t)))

             assert count == 1, "count evaluated too many times!"

 

-class OperatorPrecedenceGrammarTest4(ParseTestCase):

+class InfixNotationGrammarTest4(ParseTestCase):

     def runTest(self):

 

         import pyparsing

@@ -1269,7 +1269,7 @@ class OperatorPrecedenceGrammarTest4(ParseTestCase):
                 (pyparsing.oneOf("= !="), 2, pyparsing.opAssoc.LEFT, ),

                 (supLiteral("&"), 2, pyparsing.opAssoc.LEFT,  lambda s, l, t: ["&", t[0]]),

                 (supLiteral("|"), 2, pyparsing.opAssoc.LEFT,  lambda s, l, t: ["|", t[0]])]

-            return pyparsing.operatorPrecedence(atom, ops)

+            return pyparsing.infixNotation(atom, ops)

 

         f = booleanExpr(word) + pyparsing.StringEnd()

 

@@ -1786,14 +1786,14 @@ class SingleArgExceptionTest(ParseTestCase):
         assert raisedMsg == testMessage, "Failed to get correct exception message"

 

 

-class KeepOriginalTextTest(ParseTestCase):

+class OriginalTextForTest(ParseTestCase):

     def runTest(self):

-        from pyparsing import makeHTMLTags, keepOriginalText

+        from pyparsing import makeHTMLTags, originalTextFor

         

         def rfn(t):

             return "%s:%d" % (t.src, len("".join(t)))

 

-        makeHTMLStartTag = lambda tag: makeHTMLTags(tag)[0].setParseAction(keepOriginalText)

+        makeHTMLStartTag = lambda tag: originalTextFor(makeHTMLTags(tag)[0], asString=False)

             

         # use the lambda, Luke

         #~ start, imge = makeHTMLTags('IMG')  

@@ -2593,17 +2593,17 @@ def makeTestSuite():
     suite.addTest( VariableParseActionArgsTest() )

     suite.addTest( RepeaterTest() )

     suite.addTest( RecursiveCombineTest() )

-    suite.addTest( OperatorPrecedenceGrammarTest1() )

-    suite.addTest( OperatorPrecedenceGrammarTest2() )

-    suite.addTest( OperatorPrecedenceGrammarTest3() )

-    suite.addTest( OperatorPrecedenceGrammarTest4() )

+    suite.addTest( InfixNotationGrammarTest1() )

+    suite.addTest( InfixNotationGrammarTest2() )

+    suite.addTest( InfixNotationGrammarTest3() )

+    suite.addTest( InfixNotationGrammarTest4() )

     suite.addTest( ParseResultsPickleTest() )

     suite.addTest( ParseResultsWithNamedTupleTest() )

     suite.addTest( ParseResultsDelTest() )

     suite.addTest( SingleArgExceptionTest() )

     suite.addTest( UpcaseDowncaseUnicode() )

     if not IRON_PYTHON_ENV:

-        suite.addTest( KeepOriginalTextTest() )

+        suite.addTest( OriginalTextForTest() )

     suite.addTest( PackratParsingCacheCopyTest() )

     suite.addTest( PackratParsingCacheCopyTest2() )

     suite.addTest( WithAttributeParseActionTest() )