handle schedule 1 to 2

indigo/analysis/refs/provision_refs.peg

@@ -13,8 +13,8 @@ grammar ProvisionRefs
 
                  # Schedule 1
                  # Schedule 1A
-                 # TODO: Schedule 1 and 2
-  attachment_num_ref <- schedule__i18n WS+ main_num %attachment_num_ref
+                 # Schedule 1 and 2
+  attachment_num_ref <- schedule__i18n WS+ main_num (to_and_or main_num)* %attachment_num_ref
 
                  # the Schedule
                  # TODO: the First Schedule etc.

indigo/analysis/refs/provision_refs.py

@@ -40,106 +40,107 @@ def __init__(self, text, offset, elements):
 class TreeNode4(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode4, self).__init__(text, offset, elements)
-        self.the_schedule__i18n = elements[0]
+        self.to_and_or = elements[0]
+        self.main_num = elements[1]
 
 
 class TreeNode5(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode5, self).__init__(text, offset, elements)
-        self.unit__i18n = elements[0]
-        self.main_ref = elements[2]
+        self.the_schedule__i18n = elements[0]
 
 
 class TreeNode6(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode6, self).__init__(text, offset, elements)
-        self.to_and_or = elements[0]
-        self.main_ref = elements[1]
+        self.unit__i18n = elements[0]
+        self.main_ref = elements[2]
 
 
 class TreeNode7(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode7, self).__init__(text, offset, elements)
-        self.sub_refs = elements[1]
+        self.to_and_or = elements[0]
+        self.main_ref = elements[1]
 
 
 class TreeNode8(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode8, self).__init__(text, offset, elements)
-        self.digit = elements[0]
+        self.sub_refs = elements[1]
 
 
 class TreeNode9(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode9, self).__init__(text, offset, elements)
-        self.sub_ref = elements[0]
+        self.digit = elements[0]
 
 
 class TreeNode10(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode10, self).__init__(text, offset, elements)
-        self.to_and_or = elements[0]
-        self.sub_ref = elements[1]
+        self.sub_ref = elements[0]
 
 
 class TreeNode11(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode11, self).__init__(text, offset, elements)
-        self.num = elements[0]
+        self.to_and_or = elements[0]
+        self.sub_ref = elements[1]
 
 
 class TreeNode12(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode12, self).__init__(text, offset, elements)
-        self.num = elements[1]
+        self.num = elements[0]
 
 
 class TreeNode13(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode13, self).__init__(text, offset, elements)
-        self.to = elements[1]
+        self.num = elements[1]
 
 
 class TreeNode14(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode14, self).__init__(text, offset, elements)
-        self.comma = elements[1]
+        self.to = elements[1]
 
 
 class TreeNode15(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode15, self).__init__(text, offset, elements)
-        self.dash = elements[1]
+        self.comma = elements[1]
 
 
 class TreeNode16(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode16, self).__init__(text, offset, elements)
-        self.to__i18n = elements[1]
+        self.dash = elements[1]
 
 
 class TreeNode17(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode17, self).__init__(text, offset, elements)
-        self.and__i18n = elements[2]
+        self.to__i18n = elements[1]
 
 
 class TreeNode18(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode18, self).__init__(text, offset, elements)
-        self.comma = elements[1]
+        self.and__i18n = elements[2]
 
 
 class TreeNode19(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode19, self).__init__(text, offset, elements)
-        self.or__i18n = elements[2]
+        self.comma = elements[1]
 
 
 class TreeNode20(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode20, self).__init__(text, offset, elements)
-        self.comma = elements[1]
+        self.or__i18n = elements[2]
 
 
 class TreeNode21(TreeNode):
@@ -151,30 +152,36 @@ def __init__(self, text, offset, elements):
 class TreeNode22(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode22, self).__init__(text, offset, elements)
-        self.of_this__i18n = elements[2]
+        self.comma = elements[1]
 
 
 class TreeNode23(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode23, self).__init__(text, offset, elements)
-        self.of_the_act__i18n = elements[2]
+        self.of_this__i18n = elements[2]
 
 
 class TreeNode24(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode24, self).__init__(text, offset, elements)
-        self.of__i18n = elements[2]
+        self.of_the_act__i18n = elements[2]
 
 
 class TreeNode25(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode25, self).__init__(text, offset, elements)
-        self.thereof__i18n = elements[2]
+        self.of__i18n = elements[2]
 
 
 class TreeNode26(TreeNode):
     def __init__(self, text, offset, elements):
         super(TreeNode26, self).__init__(text, offset, elements)
+        self.thereof__i18n = elements[2]
+
+
+class TreeNode27(TreeNode):
+    def __init__(self, text, offset, elements):
+        super(TreeNode27, self).__init__(text, offset, elements)
         self.of_that_act__i18n = elements[2]
 
 
@@ -328,6 +335,43 @@ def _read_attachment_num_ref(self):
                 address4 = self._read_main_num()
                 if address4 is not FAILURE:
                     elements0.append(address4)
+                    address5 = FAILURE
+                    index3, elements2, address6 = self._offset, [], None
+                    while True:
+                        index4, elements3 = self._offset, []
+                        address7 = FAILURE
+                        address7 = self._read_to_and_or()
+                        if address7 is not FAILURE:
+                            elements3.append(address7)
+                            address8 = FAILURE
+                            address8 = self._read_main_num()
+                            if address8 is not FAILURE:
+                                elements3.append(address8)
+                            else:
+                                elements3 = None
+                                self._offset = index4
+                        else:
+                            elements3 = None
+                            self._offset = index4
+                        if elements3 is None:
+                            address6 = FAILURE
+                        else:
+                            address6 = TreeNode4(self._input[index4:self._offset], index4, elements3)
+                            self._offset = self._offset
+                        if address6 is not FAILURE:
+                            elements2.append(address6)
+                        else:
+                            break
+                    if len(elements2) >= 0:
+                        address5 = TreeNode(self._input[index3:self._offset], index3, elements2)
+                        self._offset = self._offset
+                    else:
+                        address5 = FAILURE
+                    if address5 is not FAILURE:
+                        elements0.append(address5)
+                    else:
+                        elements0 = None
+                        self._offset = index1
                 else:
                     elements0 = None
                     self._offset = index1
@@ -444,7 +488,7 @@ def _read_unit_refs(self):
                         if elements3 is None:
                             address6 = FAILURE
                         else:
-                            address6 = TreeNode6(self._input[index4:self._offset], index4, elements3)
+                            address6 = TreeNode7(self._input[index4:self._offset], index4, elements3)
                             self._offset = self._offset
                         if address6 is not FAILURE:
                             elements2.append(address6)
@@ -525,7 +569,7 @@ def _read_main_ref(self):
             if elements1 is None:
                 address2 = FAILURE
             else:
-                address2 = TreeNode7(self._input[index4:self._offset], index4, elements1)
+                address2 = TreeNode8(self._input[index4:self._offset], index4, elements1)
                 self._offset = self._offset
             if address2 is FAILURE:
                 address2 = TreeNode(self._input[index3:index3], index3, [])
@@ -618,7 +662,7 @@ def _read_sub_refs(self):
                 if elements2 is None:
                     address3 = FAILURE
                 else:
-                    address3 = TreeNode10(self._input[index3:self._offset], index3, elements2)
+                    address3 = TreeNode11(self._input[index3:self._offset], index3, elements2)
                     self._offset = self._offset
                 if address3 is not FAILURE:
                     elements1.append(address3)
@@ -688,7 +732,7 @@ def _read_sub_ref(self):
                 if elements2 is None:
                     address3 = FAILURE
                 else:
-                    address3 = TreeNode12(self._input[index3:self._offset], index3, elements2)
+                    address3 = TreeNode13(self._input[index3:self._offset], index3, elements2)
                     self._offset = self._offset
                 if address3 is not FAILURE:
                     elements1.append(address3)
@@ -840,7 +884,7 @@ def _read_range(self):
         if elements1 is None:
             address1 = FAILURE
         else:
-            address1 = TreeNode14(self._input[index3:self._offset], index3, elements1)
+            address1 = TreeNode15(self._input[index3:self._offset], index3, elements1)
             self._offset = self._offset
         if address1 is FAILURE:
             address1 = TreeNode(self._input[index2:index2], index2, [])
@@ -919,7 +963,7 @@ def _read_to(self):
         if elements0 is None:
             address0 = FAILURE
         else:
-            address0 = TreeNode15(self._input[index2:self._offset], index2, elements0)
+            address0 = TreeNode16(self._input[index2:self._offset], index2, elements0)
             self._offset = self._offset
         if address0 is FAILURE:
             self._offset = index1
@@ -970,7 +1014,7 @@ def _read_to(self):
             if elements3 is None:
                 address0 = FAILURE
             else:
-                address0 = TreeNode16(self._input[index5:self._offset], index5, elements3)
+                address0 = TreeNode17(self._input[index5:self._offset], index5, elements3)
                 self._offset = self._offset
             if address0 is FAILURE:
                 self._offset = index1
@@ -1016,7 +1060,7 @@ def _read_and_or(self):
         if elements1 is None:
             address1 = FAILURE
         else:
-            address1 = TreeNode18(self._input[index4:self._offset], index4, elements1)
+            address1 = TreeNode19(self._input[index4:self._offset], index4, elements1)
             self._offset = self._offset
         if address1 is FAILURE:
             address1 = TreeNode(self._input[index3:index3], index3, [])
@@ -1108,7 +1152,7 @@ def _read_and_or(self):
             if elements6 is None:
                 address10 = FAILURE
             else:
-                address10 = TreeNode20(self._input[index10:self._offset], index10, elements6)
+                address10 = TreeNode21(self._input[index10:self._offset], index10, elements6)
                 self._offset = self._offset
             if address10 is FAILURE:
                 address10 = TreeNode(self._input[index9:index9], index9, [])

indigo/analysis/refs/provisions.py

@@ -114,8 +114,21 @@ def root(self, input, start, end, elements):
             return ParseResult(refs, target, elements[3].offset)
 
         def attachment_num_ref(self, input, start, end, elements):
-            ref = ProvisionRef(input[start:end], start, end)
-            return [MainProvisionRef("attachment", ref)]
+            # extend the ref to cover the full thing, not just the number
+            ref = elements[2]
+            refs = [MainProvisionRef("attachment", ref)]
+            # "2" -> "Schedule 2"
+            ref.start_pos = start
+            ref.text = input[start:ref.end_pos]
+
+            for el in elements[3].elements or []:
+                ref = MainProvisionRef("attachment", el.main_num)
+                # "2" -> "Schedule 2"
+                ref.ref.text = elements[0].text + elements[1].text + ref.ref.text
+                ref.ref.separator = el.elements[0]
+                refs.append(ref)
+
+            return refs
 
         def the_attachment_ref(self, input, start, end, elements):
             text = input[start:end]

indigo/tests/test_provision_refs.py

@@ -1518,6 +1518,7 @@ def test_schedule_num(self):
                 <p>In Schedule 2</p>
                 <p>In Schedule 2.</p>
                 <p>In Schedule 2 and Schedule 2.</p>
+                <p>In Schedule 2 to 2.</p>
                 <p>In Scheduled work...</p>
                 <p>In the Schedule</p>
               </content>
@@ -1532,6 +1533,7 @@ def test_schedule_num(self):
                 <p>In <ref href="#att_1">Schedule 2</ref></p>
                 <p>In <ref href="#att_1">Schedule 2</ref>.</p>
                 <p>In <ref href="#att_1">Schedule 2</ref> and <ref href="#att_1">Schedule 2</ref>.</p>
+                <p>In <ref href="#att_1">Schedule 2</ref> to <ref href="#att_1">2</ref>.</p>
                 <p>In Scheduled work...</p>
                 <p>In the Schedule</p>
               </content>

indigo/tests/test_provision_refs_grammar.py

@@ -349,7 +349,7 @@ def test_multiple_mains_target(self):
         self.assertEqual("of", result.target)
         self.assertEqual(result.end, 49)
 
-    def test_schedules_num_eng(self):
+    def test_schedules_num(self):
         result = parse_provision_refs("Schedule 2a")
         self.assertEqual([
             MainProvisionRef(
@@ -368,6 +368,14 @@ def test_schedules_num_eng(self):
         ], result.references)
         self.assertIsNone(result.target)
 
+    def test_schedules_num_range(self):
+        result = parse_provision_refs("Schedule 2 to 30")
+        self.assertEqual([
+            MainProvisionRef('attachment', ProvisionRef('Schedule 2', 0, 10)),
+            MainProvisionRef('attachment', ProvisionRef('Schedule 30', 14, 16, separator='range')),
+        ], result.references)
+        self.assertIsNone(result.target)
+
     def test_schedules_the_eng(self):
         result = parse_provision_refs("the Schedule")
         self.assertEqual([