Source Code for Module lepl.offside._test.text

  1   
  2  # The contents of this file are subject to the Mozilla Public License 
  3  # (MPL) Version 1.1 (the "License"); you may not use this file except 
  4  # in compliance with the License. You may obtain a copy of the License 
  5  # at http://www.mozilla.org/MPL/ 
  6  # 
  7  # Software distributed under the License is distributed on an "AS IS" 
  8  # basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See 
  9  # the License for the specific language governing rights and 
 10  # limitations under the License. 
 11  # 
 12  # The Original Code is LEPL (http://www.acooke.org/lepl) 
 13  # The Initial Developer of the Original Code is Andrew Cooke. 
 14  # Portions created by the Initial Developer are Copyright (C) 2009-2010 
 15  # Andrew Cooke (andrew@acooke.org). All Rights Reserved. 
 16  # 
 17  # Alternatively, the contents of this file may be used under the terms 
 18  # of the LGPL license (the GNU Lesser General Public License, 
 19  # http://www.gnu.org/licenses/lgpl.html), in which case the provisions 
 20  # of the LGPL License are applicable instead of those above. 
 21  # 
 22  # If you wish to allow use of your version of this file only under the 
 23  # terms of the LGPL License and not to allow others to use your version 
 24  # of this file under the MPL, indicate your decision by deleting the 
 25  # provisions above and replace them with the notice and other provisions 
 26  # required by the LGPL License.  If you do not delete the provisions 
 27  # above, a recipient may use your version of this file under either the 
 28  # MPL or the LGPL License. 
 29   
 30  ''' 
 31  An example that avoids using tokens with the line aware parsing. 
 32  ''' 
 33   
 34  #from logging import basicConfig, DEBUG 
 35  from unittest import TestCase 
 36   
 37  # pylint: disable-msg=W0614 
 38  from lepl import * 
 39   
 40   
 41 -class TextTest(TestCase): 
 42   
 43 -    def parser(self, regexp): 
 44          ''' 
 45          Construct a parser that uses "offside rule" parsing, but which 
 46          avoids using tokens in the grammar. 
 47          ''' 
 48           
 49          # we still need one token, which matches "all the text" 
 50          Text = Token(regexp) 
 51           
 52          def TLine(contents): 
 53              ''' 
 54              A version of BLine() that takes text-based matchers. 
 55              ''' 
 56              return BLine(Text(contents)) 
 57           
 58          # from here on we use TLine instead of BLine and don't worry about 
 59          # tokens. 
 60           
 61          # first define the basic grammar 
 62          with Separator(~Space()[:]): 
 63              name = Word() 
 64              args = name[:, ','] 
 65              fundef = 'def' & name & '(' & args & ')' & ':' 
 66              # in reality we would have more expressions! 
 67              expression = Literal('pass')  
 68           
 69          # then define the block structure 
 70          statement = Delayed() 
 71          simple = TLine(expression) 
 72          empty = TLine(Empty()) 
 73          block = TLine(fundef) & Block(statement[:]) 
 74          statement += (simple | empty | block) > list 
 75          program = statement[:] 
 76           
 77          program.config.default_line_aware(block_policy=2) 
 78          return program.get_parse_string() 
 79           
 80 -    def do_parse(self, parser): 
 81          return parser('''pass 
 82  def foo(): 
 83    pass 
 84    def bar(): 
 85      pass 
 86  ''') 
 87           
 88 -    def test_plus(self): 
 89          parser = self.parser('[^\n]+') 
 90          result = self.do_parse(parser) 
 91          assert result == [['pass'],  
 92                            ['def', 'foo', '(', ')', ':',  
 93                             ['pass'],  
 94                             ['def', 'bar', '(', ')', ':',  
 95                              ['pass']]]], result 
 96   
 97 -    def test_star(self): 
 98          #basicConfig(level=DEBUG) 
 99          parser = self.parser('[^\n]*') 
100          try: 
101              self.do_parse(parser) 
102              assert False, 'Expected error' 
103          except RuntimeLexerError: 
104              pass 
105