Add Repeated option and port re to regex module.

examples/repeated_basic_example

@@ -0,0 +1,7 @@
+This is an example to demonstrate the usage of the 'repeated' keyword, which enables one variable to have multiple captures on one line.
+
+
+normaldata1.1 normaldata1.2 key1.1:data1.1, key1.2:data1.2, key1.3:data1.3, normaldata1.3 normaldata1.3
+normaldata2.1 normaldata2.2 key2.1:data2.1, key2.2:data2.2, normaldata2.3 normaldata2.4
+normaldata3.1 normaldata3.2 normaldata3.3 normaldata3.4
+normaldata4.1 normaldata4.2 key4.1:data4.1, key4.2:data4.2, key4.3:data4.3, normaldata4.3 normaldata4.3

examples/repeated_basic_template

@@ -0,0 +1,12 @@
+Value normaldata1 (\S+)
+Value normaldata2 (\S+)
+Value normaldata3 (\S+)
+Value normaldata4 (\S+)
+Value Repeated keything (\S+)
+Value Repeated valuedata (\S+)
+Value Repeated unusedRepeated (\S+)
+Value List unused (\S+)
+
+
+Start
+  ^${normaldata1}\s+${normaldata2} (${keything}:${valuedata},? )*${normaldata3}\s+${normaldata4} -> Record

setup.py

@@ -53,5 +53,5 @@
       },      
       include_package_data=True,
       package_data={'textfsm': ['../testdata/*']},
-      install_requires=['six', 'future'],
+      install_requires=['six', 'future', 'regex'],
      )

tests/textfsm_test.py

@@ -24,10 +24,13 @@
 from builtins import str
 import unittest
 from io import StringIO
-
-
-
 import textfsm
+from textfsm.parser import TextFSMTemplateError
+try:
+  import regex as regexModule
+  useRegex = True
+except ImportError:
+  useRegex = False
 
 
 class UnitTestFSM(unittest.TestCase):
@@ -802,7 +805,7 @@ def testEnd(self):
 
   def testInvalidRegexp(self):
 
-    tplt = 'Value boo (.$*)\n\nStart\n  ^$boo -> Next\n'
+    tplt = 'Value boo ([(\S+]))\n\nStart\n  ^$boo -> Next\n'
     self.assertRaises(textfsm.TextFSMTemplateError,
                       textfsm.TextFSM, StringIO(tplt))
 
@@ -910,6 +913,123 @@ def testTemplateValue(self):
     t = textfsm.TextFSM(f)
     self.assertEqual(str(t), buf_result)
 
+  def testRepeated(self):
+    """Repeated option should work ok."""
+    tplt = """Value Repeated repeatedKey (\S+)
+Value Repeated repeatedValue (\S+)
+Value normalData (\S+)
+Value normalData2 (\S+)
+Value Repeated repeatedUnused (\S+)
+
+Start
+  ^${normalData} (${repeatedKey}:${repeatedValue} )*${normalData2} -> Record"""
+
+    data = """
+normal1 key1:value1 key2:value2 key3:value3 normal2 \n
+normal1 normal2 """
+
+    t = textfsm.TextFSM(StringIO(tplt))
+    if useRegex is True:
+      result = t.ParseText(data)
+      self.assertListEqual(
+        [[['key1', 'key2', 'key3'], ['value1', 'value2', 'value3'], 'normal1', 'normal2', []],
+         [[], [], 'normal1', 'normal2', []]],
+        result)
+    else:
+      # test proper failure when falling back on re module
+      with self.assertRaises(TextFSMTemplateError,
+                             msg="Expected a ModuleNotFoundError when using keyword 'Repeated' without 'regex' module"):
+        result = t.ParseText(data)
+
+  def testRepeatedList(self):
+    """Keywords Repeated and List should work together"""
+    tplt = """Value List,Repeated repeatedKey (\S+)
+Value Repeated,List repeatedValue (\S+)
+Value Repeated,List repeatedUnused (\S+)
+
+Start
+  ^(${repeatedKey}:${repeatedValue} )+
+  ^record -> Record"""
+
+    data = """
+key1:value1 key2:value2 key3:value3 \n
+key4:value4 key5:value5 key6:value6 \n
+record"""
+
+    t = textfsm.TextFSM(StringIO(tplt))
+    if useRegex is True:
+      result = t.ParseText(data)
+    else:
+      return
+
+    self.assertListEqual([[[['key1', 'key2', 'key3'], ['key4', 'key5', 'key6']], [['value1', 'value2', 'value3'],
+                      ['value4', 'value5', 'value6']], []]],
+                     result
+                     )
+
+  def testRepeatedFilldown(self):
+    """Keywords Repeated and Filldown should work together"""
+    tplt = """Value Filldown,Repeated repeatedKey (\S+)
+Value Repeated,Filldown repeatedValue (\S+)
+Value Required otherMatch (\S+)
+
+Start
+  ^record -> Record
+  ^(${repeatedKey}:${repeatedValue} )+
+  ^${otherMatch}
+  """
+
+    data = """
+key1:value1 key2:value2 key3:value3 \n
+key4:value4 key5:value5 key6:value6 \n
+foo \n
+bar \n
+record \n
+foobar \n
+record"""
+
+    t = textfsm.TextFSM(StringIO(tplt))
+    if useRegex is True:
+      result = t.ParseText(data)
+    else:
+      return
+
+    self.assertListEqual([[['key4', 'key5', 'key6'], ['value4', 'value5', 'value6'], 'bar'], [['key4', 'key5', 'key6'],
+                     ['value4', 'value5', 'value6'], 'foobar']],
+                     result
+                     )
+
+  def testRepeatedFillup(self):
+    """Keywords Repeated and Fillup should work together"""
+    tplt = """Value Fillup,Repeated repeatedKey (\S+)
+Value Repeated,Fillup repeatedValue (\S+)
+Value Required otherMatch (\S+)
+
+Start
+  ^record -> Record
+  ^(${repeatedKey}:${repeatedValue} )+
+  ^${otherMatch}
+  """
+
+    data = """
+foo \n
+bar \n
+record \n
+foobar \n
+key1:value1 key2:value2 key3:value3 \n
+record"""
+
+    t = textfsm.TextFSM(StringIO(tplt))
+    if useRegex is True:
+      result = t.ParseText(data)
+    else:
+      return
+
+    self.assertListEqual([[['key1', 'key2', 'key3'], ['value1', 'value2', 'value3'], 'bar'],
+                     [['key1', 'key2', 'key3'], ['value1', 'value2', 'value3'], 'foobar']],
+                     result
+                     )
+
 
 if __name__ == '__main__':
   unittest.main()

textfsm/copyable_regex_object.py

@@ -16,8 +16,11 @@
 
 """Work around a regression in Python 2.6 that makes RegexObjects uncopyable."""
 
+try:
+  import regex as regexModule
+except ImportError:
+  import re as regexModule
 
-import re
 from builtins import object    # pylint: disable=redefined-builtin
 
 
@@ -26,7 +29,7 @@ class CopyableRegexObject(object):
 
   def __init__(self, pattern):
     self.pattern = pattern
-    self.regex = re.compile(pattern)
+    self.regex = regexModule.compile(pattern)
 
   def match(self, *args, **kwargs):
     return self.regex.match(*args, **kwargs)