regexp-examples 0.2.4 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/coverage/index.html CHANGED
@@ -14,7 +14,7 @@
14
14
  <img src="./assets/0.8.0/loading.gif" alt="loading"/>
15
15
  </div>
16
16
  <div id="wrapper" style="display:none;">
17
- <div class="timestamp">Generated <abbr class="timeago" title="2015-01-17T16:37:30+00:00">2015-01-17T16:37:30+00:00</abbr></div>
17
+ <div class="timestamp">Generated <abbr class="timeago" title="2015-01-17T18:36:38+00:00">2015-01-17T18:36:38+00:00</abbr></div>
18
18
  <ul class="group_tabs"></ul>
19
19
 
20
20
  <div id="content">
@@ -25,15 +25,15 @@
25
25
  covered at
26
26
  <span class="covered_strength">
27
27
  <span class="green">
28
- 74.89
28
+ 76.72
29
29
  </span>
30
30
  </span> hits/line)
31
31
  </h2>
32
32
  <a name="AllFiles"></a>
33
33
  <div>
34
34
  <b>10</b> files in total.
35
- <b>316</b> relevant lines.
36
- <span class="green"><b>316</b> lines covered</span> and
35
+ <b>343</b> relevant lines.
36
+ <span class="green"><b>343</b> lines covered</span> and
37
37
  <span class="red"><b>0</b> lines missed </span>
38
38
  </div>
39
39
  <table class="file_list">
@@ -67,7 +67,7 @@
67
67
  <td>11</td>
68
68
  <td>11</td>
69
69
  <td>0</td>
70
- <td>48.7</td>
70
+ <td>50.4</td>
71
71
  </tr>
72
72
 
73
73
  <tr>
@@ -97,7 +97,7 @@
97
97
  <td>77</td>
98
98
  <td>77</td>
99
99
  <td>0</td>
100
- <td>149.5</td>
100
+ <td>156.5</td>
101
101
  </tr>
102
102
 
103
103
  <tr>
@@ -107,17 +107,17 @@
107
107
  <td>10</td>
108
108
  <td>10</td>
109
109
  <td>0</td>
110
- <td>171.5</td>
110
+ <td>188.8</td>
111
111
  </tr>
112
112
 
113
113
  <tr>
114
114
  <td class="strong"><a href="#d0056bbc5aec01e743374a8696b2086c03bae8f0" class="src_link" title="lib/regexp-examples/parser.rb">lib/regexp-examples/parser.rb</a></td>
115
115
  <td class="green strong">100.0 %</td>
116
- <td>205</td>
117
- <td>116</td>
118
- <td>116</td>
116
+ <td>240</td>
117
+ <td>135</td>
118
+ <td>135</td>
119
119
  <td>0</td>
120
- <td>53.0</td>
120
+ <td>56.2</td>
121
121
  </tr>
122
122
 
123
123
  <tr>
@@ -127,7 +127,7 @@
127
127
  <td>8</td>
128
128
  <td>8</td>
129
129
  <td>0</td>
130
- <td>43.5</td>
130
+ <td>51.0</td>
131
131
  </tr>
132
132
 
133
133
  <tr>
@@ -137,17 +137,17 @@
137
137
  <td>43</td>
138
138
  <td>43</td>
139
139
  <td>0</td>
140
- <td>65.6</td>
140
+ <td>73.6</td>
141
141
  </tr>
142
142
 
143
143
  <tr>
144
144
  <td class="strong"><a href="#953f94f8f5f8bad7e1fa800f942a74b781f8fa1c" class="src_link" title="spec/regexp-examples_spec.rb">spec/regexp-examples_spec.rb</a></td>
145
145
  <td class="green strong">100.0 %</td>
146
- <td>155</td>
147
- <td>34</td>
148
- <td>34</td>
146
+ <td>192</td>
147
+ <td>42</td>
148
+ <td>42</td>
149
149
  <td>0</td>
150
- <td>14.4</td>
150
+ <td>13.5</td>
151
151
  </tr>
152
152
 
153
153
  </tbody>
@@ -228,14 +228,14 @@
228
228
  <code class="ruby"> def substitute_backreferences(full_examples)</code>
229
229
  </li>
230
230
 
231
- <li class="covered" data-hits="69" data-linenumber="4">
232
- <span class="hits">69</span>
231
+ <li class="covered" data-hits="75" data-linenumber="4">
232
+ <span class="hits">75</span>
233
233
 
234
234
  <code class="ruby"> full_examples.map do |full_example|</code>
235
235
  </li>
236
236
 
237
- <li class="covered" data-hits="165" data-linenumber="5">
238
- <span class="hits">165</span>
237
+ <li class="covered" data-hits="171" data-linenumber="5">
238
+ <span class="hits">171</span>
239
239
 
240
240
  <code class="ruby"> while full_example.match(/__(\w+?)__/)</code>
241
241
  </li>
@@ -252,8 +252,8 @@
252
252
  <code class="ruby"> end</code>
253
253
  </li>
254
254
 
255
- <li class="covered" data-hits="165" data-linenumber="8">
256
- <span class="hits">165</span>
255
+ <li class="covered" data-hits="171" data-linenumber="8">
256
+ <span class="hits">171</span>
257
257
 
258
258
  <code class="ruby"> full_example</code>
259
259
  </li>
@@ -714,20 +714,20 @@
714
714
  <code class="ruby"> def initialize(result, group_id = nil, subgroups = [])</code>
715
715
  </li>
716
716
 
717
- <li class="covered" data-hits="1677" data-linenumber="8">
718
- <span class="hits">1677</span>
717
+ <li class="covered" data-hits="1758" data-linenumber="8">
718
+ <span class="hits">1758</span>
719
719
 
720
720
  <code class="ruby"> @group_id = group_id</code>
721
721
  </li>
722
722
 
723
- <li class="covered" data-hits="1677" data-linenumber="9">
724
- <span class="hits">1677</span>
723
+ <li class="covered" data-hits="1758" data-linenumber="9">
724
+ <span class="hits">1758</span>
725
725
 
726
726
  <code class="ruby"> @subgroups = subgroups</code>
727
727
  </li>
728
728
 
729
- <li class="covered" data-hits="1677" data-linenumber="10">
730
- <span class="hits">1677</span>
729
+ <li class="covered" data-hits="1758" data-linenumber="10">
730
+ <span class="hits">1758</span>
731
731
 
732
732
  <code class="ruby"> if result.respond_to?(:group_id)</code>
733
733
  </li>
@@ -744,8 +744,8 @@
744
744
  <code class="ruby"> end</code>
745
745
  </li>
746
746
 
747
- <li class="covered" data-hits="1677" data-linenumber="13">
748
- <span class="hits">1677</span>
747
+ <li class="covered" data-hits="1758" data-linenumber="13">
748
+ <span class="hits">1758</span>
749
749
 
750
750
  <code class="ruby"> super(result)</code>
751
751
  </li>
@@ -768,8 +768,8 @@
768
768
  <code class="ruby"> def all_subgroups</code>
769
769
  </li>
770
770
 
771
- <li class="covered" data-hits="1683" data-linenumber="17">
772
- <span class="hits">1683</span>
771
+ <li class="covered" data-hits="1775" data-linenumber="17">
772
+ <span class="hits">1775</span>
773
773
 
774
774
  <code class="ruby"> [self, subgroups].flatten.reject { |subgroup| subgroup.group_id.nil? }</code>
775
775
  </li>
@@ -804,8 +804,8 @@
804
804
  <code class="ruby"> def *(int)</code>
805
805
  </li>
806
806
 
807
- <li class="covered" data-hits="434" data-linenumber="23">
808
- <span class="hits">434</span>
807
+ <li class="covered" data-hits="463" data-linenumber="23">
808
+ <span class="hits">463</span>
809
809
 
810
810
  <code class="ruby"> self.class.new(super.to_s, group_id, subgroups)</code>
811
811
  </li>
@@ -840,8 +840,8 @@
840
840
  <code class="ruby"> def initialize(char)</code>
841
841
  </li>
842
842
 
843
- <li class="covered" data-hits="194" data-linenumber="29">
844
- <span class="hits">194</span>
843
+ <li class="covered" data-hits="261" data-linenumber="29">
844
+ <span class="hits">261</span>
845
845
 
846
846
  <code class="ruby"> @char = char</code>
847
847
  </li>
@@ -858,8 +858,8 @@
858
858
  <code class="ruby"> def result</code>
859
859
  </li>
860
860
 
861
- <li class="covered" data-hits="194" data-linenumber="32">
862
- <span class="hits">194</span>
861
+ <li class="covered" data-hits="223" data-linenumber="32">
862
+ <span class="hits">223</span>
863
863
 
864
864
  <code class="ruby"> [GroupResult.new(@char)]</code>
865
865
  </li>
@@ -1620,26 +1620,26 @@
1620
1620
  <code class="ruby"> def self.permutations_of_strings(arrays_of_strings, options={})</code>
1621
1621
  </li>
1622
1622
 
1623
- <li class="covered" data-hits="290" data-linenumber="11">
1624
- <span class="hits">290</span>
1623
+ <li class="covered" data-hits="319" data-linenumber="11">
1624
+ <span class="hits">319</span>
1625
1625
 
1626
1626
  <code class="ruby"> first = arrays_of_strings.shift</code>
1627
1627
  </li>
1628
1628
 
1629
- <li class="covered" data-hits="290" data-linenumber="12">
1630
- <span class="hits">290</span>
1629
+ <li class="covered" data-hits="319" data-linenumber="12">
1630
+ <span class="hits">319</span>
1631
1631
 
1632
1632
  <code class="ruby"> return first if arrays_of_strings.empty?</code>
1633
1633
  </li>
1634
1634
 
1635
- <li class="covered" data-hits="168" data-linenumber="13">
1636
- <span class="hits">168</span>
1635
+ <li class="covered" data-hits="191" data-linenumber="13">
1636
+ <span class="hits">191</span>
1637
1637
 
1638
1638
  <code class="ruby"> first.product( permutations_of_strings(arrays_of_strings, options) ).map do |result|</code>
1639
1639
  </li>
1640
1640
 
1641
- <li class="covered" data-hits="241" data-linenumber="14">
1642
- <span class="hits">241</span>
1641
+ <li class="covered" data-hits="264" data-linenumber="14">
1642
+ <span class="hits">264</span>
1643
1643
 
1644
1644
  <code class="ruby"> join_preserving_capture_groups(result)</code>
1645
1645
  </li>
@@ -1668,14 +1668,14 @@
1668
1668
  <code class="ruby"> def self.join_preserving_capture_groups(result)</code>
1669
1669
  </li>
1670
1670
 
1671
- <li class="covered" data-hits="241" data-linenumber="19">
1672
- <span class="hits">241</span>
1671
+ <li class="covered" data-hits="264" data-linenumber="19">
1672
+ <span class="hits">264</span>
1673
1673
 
1674
1674
  <code class="ruby"> result.flatten!</code>
1675
1675
  </li>
1676
1676
 
1677
- <li class="covered" data-hits="241" data-linenumber="20">
1678
- <span class="hits">241</span>
1677
+ <li class="covered" data-hits="264" data-linenumber="20">
1678
+ <span class="hits">264</span>
1679
1679
 
1680
1680
  <code class="ruby"> subgroups = result</code>
1681
1681
  </li>
@@ -1692,8 +1692,8 @@
1692
1692
  <code class="ruby"> .flatten</code>
1693
1693
  </li>
1694
1694
 
1695
- <li class="covered" data-hits="241" data-linenumber="23">
1696
- <span class="hits">241</span>
1695
+ <li class="covered" data-hits="264" data-linenumber="23">
1696
+ <span class="hits">264</span>
1697
1697
 
1698
1698
  <code class="ruby"> GroupResult.new(result.join, nil, subgroups)</code>
1699
1699
  </li>
@@ -1725,8 +1725,8 @@
1725
1725
  <h3>lib/regexp-examples/parser.rb</h3>
1726
1726
  <h4><span class="green">100.0 %</span> covered</h4>
1727
1727
  <div>
1728
- <b>116</b> relevant lines.
1729
- <span class="green"><b>116</b> lines covered</span> and
1728
+ <b>135</b> relevant lines.
1729
+ <span class="green"><b>135</b> lines covered</span> and
1730
1730
  <span class="red"><b>0</b> lines missed.</span>
1731
1731
  </div>
1732
1732
  </div>
@@ -1758,20 +1758,20 @@
1758
1758
  <code class="ruby"> def initialize(regexp_string)</code>
1759
1759
  </li>
1760
1760
 
1761
- <li class="covered" data-hits="73" data-linenumber="5">
1762
- <span class="hits">73</span>
1761
+ <li class="covered" data-hits="92" data-linenumber="5">
1762
+ <span class="hits">92</span>
1763
1763
 
1764
1764
  <code class="ruby"> @regexp_string = regexp_string</code>
1765
1765
  </li>
1766
1766
 
1767
- <li class="covered" data-hits="73" data-linenumber="6">
1768
- <span class="hits">73</span>
1767
+ <li class="covered" data-hits="92" data-linenumber="6">
1768
+ <span class="hits">92</span>
1769
1769
 
1770
1770
  <code class="ruby"> @num_groups = 0</code>
1771
1771
  </li>
1772
1772
 
1773
- <li class="covered" data-hits="73" data-linenumber="7">
1774
- <span class="hits">73</span>
1773
+ <li class="covered" data-hits="92" data-linenumber="7">
1774
+ <span class="hits">92</span>
1775
1775
 
1776
1776
  <code class="ruby"> @current_position = 0</code>
1777
1777
  </li>
@@ -1794,44 +1794,44 @@
1794
1794
  <code class="ruby"> def parse</code>
1795
1795
  </li>
1796
1796
 
1797
- <li class="covered" data-hits="120" data-linenumber="11">
1798
- <span class="hits">120</span>
1797
+ <li class="covered" data-hits="140" data-linenumber="11">
1798
+ <span class="hits">140</span>
1799
1799
 
1800
1800
  <code class="ruby"> repeaters = []</code>
1801
1801
  </li>
1802
1802
 
1803
- <li class="covered" data-hits="120" data-linenumber="12">
1804
- <span class="hits">120</span>
1803
+ <li class="covered" data-hits="140" data-linenumber="12">
1804
+ <span class="hits">140</span>
1805
1805
 
1806
1806
  <code class="ruby"> while @current_position &lt; regexp_string.length</code>
1807
1807
  </li>
1808
1808
 
1809
- <li class="covered" data-hits="335" data-linenumber="13">
1810
- <span class="hits">335</span>
1809
+ <li class="covered" data-hits="419" data-linenumber="13">
1810
+ <span class="hits">419</span>
1811
1811
 
1812
1812
  <code class="ruby"> group = parse_group(repeaters)</code>
1813
1813
  </li>
1814
1814
 
1815
- <li class="covered" data-hits="331" data-linenumber="14">
1816
- <span class="hits">331</span>
1815
+ <li class="covered" data-hits="401" data-linenumber="14">
1816
+ <span class="hits">401</span>
1817
1817
 
1818
1818
  <code class="ruby"> break if group.is_a? MultiGroupEnd</code>
1819
1819
  </li>
1820
1820
 
1821
- <li class="covered" data-hits="290" data-linenumber="15">
1822
- <span class="hits">290</span>
1821
+ <li class="covered" data-hits="360" data-linenumber="15">
1822
+ <span class="hits">360</span>
1823
1823
 
1824
1824
  <code class="ruby"> repeaters = [] if group.is_a? OrGroup</code>
1825
1825
  </li>
1826
1826
 
1827
- <li class="covered" data-hits="290" data-linenumber="16">
1828
- <span class="hits">290</span>
1827
+ <li class="covered" data-hits="360" data-linenumber="16">
1828
+ <span class="hits">360</span>
1829
1829
 
1830
1830
  <code class="ruby"> @current_position += 1</code>
1831
1831
  </li>
1832
1832
 
1833
- <li class="covered" data-hits="290" data-linenumber="17">
1834
- <span class="hits">290</span>
1833
+ <li class="covered" data-hits="360" data-linenumber="17">
1834
+ <span class="hits">360</span>
1835
1835
 
1836
1836
  <code class="ruby"> repeaters &lt;&lt; parse_repeater(group)</code>
1837
1837
  </li>
@@ -1842,8 +1842,8 @@
1842
1842
  <code class="ruby"> end</code>
1843
1843
  </li>
1844
1844
 
1845
- <li class="covered" data-hits="116" data-linenumber="19">
1846
- <span class="hits">116</span>
1845
+ <li class="covered" data-hits="122" data-linenumber="19">
1846
+ <span class="hits">122</span>
1847
1847
 
1848
1848
  <code class="ruby"> repeaters</code>
1849
1849
  </li>
@@ -1878,14 +1878,14 @@
1878
1878
  <code class="ruby"> def parse_group(repeaters)</code>
1879
1879
  </li>
1880
1880
 
1881
- <li class="covered" data-hits="335" data-linenumber="25">
1882
- <span class="hits">335</span>
1881
+ <li class="covered" data-hits="419" data-linenumber="25">
1882
+ <span class="hits">419</span>
1883
1883
 
1884
1884
  <code class="ruby"> char = regexp_string[@current_position]</code>
1885
1885
  </li>
1886
1886
 
1887
- <li class="covered" data-hits="335" data-linenumber="26">
1888
- <span class="hits">335</span>
1887
+ <li class="covered" data-hits="419" data-linenumber="26">
1888
+ <span class="hits">419</span>
1889
1889
 
1890
1890
  <code class="ruby"> case char</code>
1891
1891
  </li>
@@ -1896,8 +1896,8 @@
1896
1896
  <code class="ruby"> when &#39;(&#39;</code>
1897
1897
  </li>
1898
1898
 
1899
- <li class="covered" data-hits="45" data-linenumber="28">
1900
- <span class="hits">45</span>
1899
+ <li class="covered" data-hits="46" data-linenumber="28">
1900
+ <span class="hits">46</span>
1901
1901
 
1902
1902
  <code class="ruby"> group = parse_multi_group</code>
1903
1903
  </li>
@@ -1920,8 +1920,8 @@
1920
1920
  <code class="ruby"> when &#39;[&#39;</code>
1921
1921
  </li>
1922
1922
 
1923
- <li class="covered" data-hits="14" data-linenumber="32">
1924
- <span class="hits">14</span>
1923
+ <li class="covered" data-hits="15" data-linenumber="32">
1924
+ <span class="hits">15</span>
1925
1925
 
1926
1926
  <code class="ruby"> group = parse_char_group</code>
1927
1927
  </li>
@@ -1932,8 +1932,8 @@
1932
1932
  <code class="ruby"> when &#39;.&#39;</code>
1933
1933
  </li>
1934
1934
 
1935
- <li class="covered" data-hits="1" data-linenumber="34">
1936
- <span class="hits">1</span>
1935
+ <li class="covered" data-hits="4" data-linenumber="34">
1936
+ <span class="hits">4</span>
1937
1937
 
1938
1938
  <code class="ruby"> group = parse_dot_group</code>
1939
1939
  </li>
@@ -1956,8 +1956,8 @@
1956
1956
  <code class="ruby"> when &#39;\\&#39;</code>
1957
1957
  </li>
1958
1958
 
1959
- <li class="covered" data-hits="49" data-linenumber="38">
1960
- <span class="hits">49</span>
1959
+ <li class="covered" data-hits="63" data-linenumber="38">
1960
+ <span class="hits">63</span>
1961
1961
 
1962
1962
  <code class="ruby"> group = parse_after_backslash_group</code>
1963
1963
  </li>
@@ -1965,1000 +1965,1210 @@
1965
1965
  <li class="never" data-hits="" data-linenumber="39">
1966
1966
 
1967
1967
 
1968
+ <code class="ruby"> when &#39;^&#39;, &#39;A&#39;</code>
1969
+ </li>
1970
+
1971
+ <li class="covered" data-hits="2" data-linenumber="40">
1972
+ <span class="hits">2</span>
1973
+
1974
+ <code class="ruby"> if @current_position == 0</code>
1975
+ </li>
1976
+
1977
+ <li class="covered" data-hits="1" data-linenumber="41">
1978
+ <span class="hits">1</span>
1979
+
1980
+ <code class="ruby"> group = parse_single_char_group(&#39;&#39;) # Ignore the &quot;illegal&quot; character</code>
1981
+ </li>
1982
+
1983
+ <li class="never" data-hits="" data-linenumber="42">
1984
+
1985
+
1986
+ <code class="ruby"> else</code>
1987
+ </li>
1988
+
1989
+ <li class="covered" data-hits="1" data-linenumber="43">
1990
+ <span class="hits">1</span>
1991
+
1992
+ <code class="ruby"> raise IllegalSyntaxError, &quot;Anchors cannot be supported, as they are not regular&quot;</code>
1993
+ </li>
1994
+
1995
+ <li class="never" data-hits="" data-linenumber="44">
1996
+
1997
+
1998
+ <code class="ruby"> end</code>
1999
+ </li>
2000
+
2001
+ <li class="never" data-hits="" data-linenumber="45">
2002
+
2003
+
2004
+ <code class="ruby"> when &#39;$&#39;, &#39;z&#39;, &#39;Z&#39;</code>
2005
+ </li>
2006
+
2007
+ <li class="covered" data-hits="2" data-linenumber="46">
2008
+ <span class="hits">2</span>
2009
+
2010
+ <code class="ruby"> if @current_position == (regexp_string.length - 1)</code>
2011
+ </li>
2012
+
2013
+ <li class="covered" data-hits="1" data-linenumber="47">
2014
+ <span class="hits">1</span>
2015
+
2016
+ <code class="ruby"> group = parse_single_char_group(&#39;&#39;) # Ignore the &quot;illegal&quot; character</code>
2017
+ </li>
2018
+
2019
+ <li class="never" data-hits="" data-linenumber="48">
2020
+
2021
+
2022
+ <code class="ruby"> else</code>
2023
+ </li>
2024
+
2025
+ <li class="covered" data-hits="1" data-linenumber="49">
2026
+ <span class="hits">1</span>
2027
+
2028
+ <code class="ruby"> raise IllegalSyntaxError, &quot;Anchors cannot be supported, as they are not regular&quot;</code>
2029
+ </li>
2030
+
2031
+ <li class="never" data-hits="" data-linenumber="50">
2032
+
2033
+
2034
+ <code class="ruby"> end</code>
2035
+ </li>
2036
+
2037
+ <li class="never" data-hits="" data-linenumber="51">
2038
+
2039
+
1968
2040
  <code class="ruby"> else</code>
1969
2041
  </li>
1970
2042
 
1971
- <li class="covered" data-hits="179" data-linenumber="40">
1972
- <span class="hits">179</span>
2043
+ <li class="covered" data-hits="240" data-linenumber="52">
2044
+ <span class="hits">240</span>
1973
2045
 
1974
2046
  <code class="ruby"> group = parse_single_char_group(char)</code>
1975
2047
  </li>
1976
2048
 
1977
- <li class="never" data-hits="" data-linenumber="41">
2049
+ <li class="never" data-hits="" data-linenumber="53">
1978
2050
 
1979
2051
 
1980
2052
  <code class="ruby"> end</code>
1981
2053
  </li>
1982
2054
 
1983
- <li class="covered" data-hits="331" data-linenumber="42">
1984
- <span class="hits">331</span>
2055
+ <li class="covered" data-hits="401" data-linenumber="54">
2056
+ <span class="hits">401</span>
1985
2057
 
1986
2058
  <code class="ruby"> group</code>
1987
2059
  </li>
1988
2060
 
1989
- <li class="never" data-hits="" data-linenumber="43">
2061
+ <li class="never" data-hits="" data-linenumber="55">
1990
2062
 
1991
2063
 
1992
2064
  <code class="ruby"> end</code>
1993
2065
  </li>
1994
2066
 
1995
- <li class="never" data-hits="" data-linenumber="44">
2067
+ <li class="never" data-hits="" data-linenumber="56">
1996
2068
 
1997
2069
 
1998
2070
  <code class="ruby"></code>
1999
2071
  </li>
2000
2072
 
2001
- <li class="covered" data-hits="1" data-linenumber="45">
2073
+ <li class="covered" data-hits="1" data-linenumber="57">
2002
2074
  <span class="hits">1</span>
2003
2075
 
2004
2076
  <code class="ruby"> def parse_after_backslash_group</code>
2005
2077
  </li>
2006
2078
 
2007
- <li class="covered" data-hits="49" data-linenumber="46">
2008
- <span class="hits">49</span>
2079
+ <li class="covered" data-hits="63" data-linenumber="58">
2080
+ <span class="hits">63</span>
2009
2081
 
2010
2082
  <code class="ruby"> @current_position += 1</code>
2011
2083
  </li>
2012
2084
 
2013
- <li class="never" data-hits="" data-linenumber="47">
2085
+ <li class="never" data-hits="" data-linenumber="59">
2014
2086
 
2015
2087
 
2016
2088
  <code class="ruby"> case</code>
2017
2089
  </li>
2018
2090
 
2019
- <li class="never" data-hits="" data-linenumber="48">
2091
+ <li class="never" data-hits="" data-linenumber="60">
2020
2092
 
2021
2093
 
2022
2094
  <code class="ruby"> when rest_of_string =~ /\A(\d+)/</code>
2023
2095
  </li>
2024
2096
 
2025
- <li class="covered" data-hits="19" data-linenumber="49">
2097
+ <li class="covered" data-hits="19" data-linenumber="61">
2026
2098
  <span class="hits">19</span>
2027
2099
 
2028
2100
  <code class="ruby"> @current_position += ($1.length - 1) # In case of 10+ backrefs!</code>
2029
2101
  </li>
2030
2102
 
2031
- <li class="covered" data-hits="19" data-linenumber="50">
2103
+ <li class="covered" data-hits="19" data-linenumber="62">
2032
2104
  <span class="hits">19</span>
2033
2105
 
2034
2106
  <code class="ruby"> group = parse_backreference_group($1)</code>
2035
2107
  </li>
2036
2108
 
2037
- <li class="never" data-hits="" data-linenumber="51">
2109
+ <li class="never" data-hits="" data-linenumber="63">
2038
2110
 
2039
2111
 
2040
2112
  <code class="ruby"> when rest_of_string =~ /\Ak&lt;([^&gt;]+)&gt;/ # Named capture group</code>
2041
2113
  </li>
2042
2114
 
2043
- <li class="covered" data-hits="1" data-linenumber="52">
2115
+ <li class="covered" data-hits="1" data-linenumber="64">
2044
2116
  <span class="hits">1</span>
2045
2117
 
2046
2118
  <code class="ruby"> @current_position += ($1.length + 2)</code>
2047
2119
  </li>
2048
2120
 
2049
- <li class="covered" data-hits="1" data-linenumber="53">
2121
+ <li class="covered" data-hits="1" data-linenumber="65">
2050
2122
  <span class="hits">1</span>
2051
2123
 
2052
2124
  <code class="ruby"> group = parse_backreference_group($1)</code>
2053
2125
  </li>
2054
2126
 
2055
- <li class="never" data-hits="" data-linenumber="54">
2127
+ <li class="never" data-hits="" data-linenumber="66">
2056
2128
 
2057
2129
 
2058
2130
  <code class="ruby"> when BackslashCharMap.keys.include?(regexp_string[@current_position])</code>
2059
2131
  </li>
2060
2132
 
2061
- <li class="covered" data-hits="14" data-linenumber="55">
2133
+ <li class="covered" data-hits="14" data-linenumber="67">
2062
2134
  <span class="hits">14</span>
2063
2135
 
2064
2136
  <code class="ruby"> group = CharGroup.new(</code>
2065
2137
  </li>
2066
2138
 
2067
- <li class="never" data-hits="" data-linenumber="56">
2139
+ <li class="never" data-hits="" data-linenumber="68">
2068
2140
 
2069
2141
 
2070
2142
  <code class="ruby"> BackslashCharMap[regexp_string[@current_position]])</code>
2071
2143
  </li>
2072
2144
 
2073
- <li class="never" data-hits="" data-linenumber="57">
2145
+ <li class="never" data-hits="" data-linenumber="69">
2074
2146
 
2075
2147
 
2076
2148
  <code class="ruby"> when rest_of_string =~ /\A(c|C-)(.)/ # Control character</code>
2077
2149
  </li>
2078
2150
 
2079
- <li class="never" data-hits="" data-linenumber="58">
2080
-
2081
-
2082
- <code class="ruby"> # http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Literals</code>
2083
- </li>
2084
-
2085
- <li class="covered" data-hits="8" data-linenumber="59">
2151
+ <li class="covered" data-hits="8" data-linenumber="70">
2086
2152
  <span class="hits">8</span>
2087
2153
 
2088
2154
  <code class="ruby"> @current_position += $1.length</code>
2089
2155
  </li>
2090
2156
 
2091
- <li class="covered" data-hits="8" data-linenumber="60">
2157
+ <li class="covered" data-hits="8" data-linenumber="71">
2092
2158
  <span class="hits">8</span>
2093
2159
 
2094
2160
  <code class="ruby"> group = parse_single_char_group( parse_control_character($2) )</code>
2095
2161
  </li>
2096
2162
 
2097
- <li class="never" data-hits="" data-linenumber="61">
2163
+ <li class="never" data-hits="" data-linenumber="72">
2098
2164
 
2099
2165
 
2100
2166
  <code class="ruby"> when rest_of_string =~ /\Ax(\h{1,2})/ # Escape sequence</code>
2101
2167
  </li>
2102
2168
 
2103
- <li class="covered" data-hits="3" data-linenumber="62">
2169
+ <li class="covered" data-hits="3" data-linenumber="73">
2104
2170
  <span class="hits">3</span>
2105
2171
 
2106
2172
  <code class="ruby"> @current_position += $1.length</code>
2107
2173
  </li>
2108
2174
 
2109
- <li class="covered" data-hits="3" data-linenumber="63">
2175
+ <li class="covered" data-hits="3" data-linenumber="74">
2110
2176
  <span class="hits">3</span>
2111
2177
 
2112
2178
  <code class="ruby"> group = parse_single_char_group( parse_escape_sequence($1) )</code>
2113
2179
  </li>
2114
2180
 
2115
- <li class="never" data-hits="" data-linenumber="64">
2181
+ <li class="never" data-hits="" data-linenumber="75">
2116
2182
 
2117
2183
 
2118
- <code class="ruby"> when rest_of_string =~ /\Au(\h{4})/ # Unicode sequence</code>
2184
+ <code class="ruby"> when rest_of_string =~ /\Au(\h{4}|\{\h{1,4}\})/ # Unicode sequence</code>
2119
2185
  </li>
2120
2186
 
2121
- <li class="covered" data-hits="2" data-linenumber="65">
2187
+ <li class="covered" data-hits="3" data-linenumber="76">
2188
+ <span class="hits">3</span>
2189
+
2190
+ <code class="ruby"> @current_position += $1.length</code>
2191
+ </li>
2192
+
2193
+ <li class="covered" data-hits="3" data-linenumber="77">
2194
+ <span class="hits">3</span>
2195
+
2196
+ <code class="ruby"> sequence = $1.match(/\h{1,4}/)[0] # Strip off &quot;{&quot; and &quot;}&quot;</code>
2197
+ </li>
2198
+
2199
+ <li class="covered" data-hits="3" data-linenumber="78">
2200
+ <span class="hits">3</span>
2201
+
2202
+ <code class="ruby"> group = parse_single_char_group( parse_unicode_sequence(sequence) )</code>
2203
+ </li>
2204
+
2205
+ <li class="never" data-hits="" data-linenumber="79">
2206
+
2207
+
2208
+ <code class="ruby"> when rest_of_string =~ /\Ap\{([^}]+)\}/ # Named properties</code>
2209
+ </li>
2210
+
2211
+ <li class="covered" data-hits="3" data-linenumber="80">
2212
+ <span class="hits">3</span>
2213
+
2214
+ <code class="ruby"> @current_position += ($1.length + 2)</code>
2215
+ </li>
2216
+
2217
+ <li class="covered" data-hits="3" data-linenumber="81">
2218
+ <span class="hits">3</span>
2219
+
2220
+ <code class="ruby"> raise UnsupportedSyntaxError, &quot;Named properties ({\\p#{$1}}) are not yet supported&quot;</code>
2221
+ </li>
2222
+
2223
+ <li class="never" data-hits="" data-linenumber="82">
2224
+
2225
+
2226
+ <code class="ruby"> when rest_of_string =~ /\Ag/ # Subexpression call</code>
2227
+ </li>
2228
+
2229
+ <li class="never" data-hits="" data-linenumber="83">
2230
+
2231
+
2232
+ <code class="ruby"> # TODO: Should this be IllegalSyntaxError ?</code>
2233
+ </li>
2234
+
2235
+ <li class="covered" data-hits="1" data-linenumber="84">
2236
+ <span class="hits">1</span>
2237
+
2238
+ <code class="ruby"> raise UnsupportedSyntaxError, &quot;Subexpression calls (\g) are not yet supported&quot;</code>
2239
+ </li>
2240
+
2241
+ <li class="never" data-hits="" data-linenumber="85">
2242
+
2243
+
2244
+ <code class="ruby"> when rest_of_string =~ /\A[GbB]/ # Anchors</code>
2245
+ </li>
2246
+
2247
+ <li class="covered" data-hits="3" data-linenumber="86">
2248
+ <span class="hits">3</span>
2249
+
2250
+ <code class="ruby"> raise IllegalSyntaxError, &quot;Anchors cannot be supported, as they are not regular&quot;</code>
2251
+ </li>
2252
+
2253
+ <li class="never" data-hits="" data-linenumber="87">
2254
+
2255
+
2256
+ <code class="ruby"> when rest_of_string =~ /\AA/ # Start of string</code>
2257
+ </li>
2258
+
2259
+ <li class="covered" data-hits="2" data-linenumber="88">
2122
2260
  <span class="hits">2</span>
2123
2261
 
2124
- <code class="ruby"> @current_position += 4</code>
2262
+ <code class="ruby"> if @current_position == 1</code>
2263
+ </li>
2264
+
2265
+ <li class="covered" data-hits="1" data-linenumber="89">
2266
+ <span class="hits">1</span>
2267
+
2268
+ <code class="ruby"> group = parse_single_char_group(&#39;&#39;) # Ignore the &quot;illegal&quot; character</code>
2269
+ </li>
2270
+
2271
+ <li class="never" data-hits="" data-linenumber="90">
2272
+
2273
+
2274
+ <code class="ruby"> else</code>
2275
+ </li>
2276
+
2277
+ <li class="covered" data-hits="1" data-linenumber="91">
2278
+ <span class="hits">1</span>
2279
+
2280
+ <code class="ruby"> raise IllegalSyntaxError, &quot;Anchors cannot be supported, as they are not regular&quot;</code>
2281
+ </li>
2282
+
2283
+ <li class="never" data-hits="" data-linenumber="92">
2284
+
2285
+
2286
+ <code class="ruby"> end</code>
2287
+ </li>
2288
+
2289
+ <li class="never" data-hits="" data-linenumber="93">
2290
+
2291
+
2292
+ <code class="ruby"> when rest_of_string =~ /\A[zZ]/ # End of string</code>
2293
+ </li>
2294
+
2295
+ <li class="covered" data-hits="4" data-linenumber="94">
2296
+ <span class="hits">4</span>
2297
+
2298
+ <code class="ruby"> if @current_position == (regexp_string.length - 1)</code>
2125
2299
  </li>
2126
2300
 
2127
- <li class="covered" data-hits="2" data-linenumber="66">
2301
+ <li class="covered" data-hits="2" data-linenumber="95">
2128
2302
  <span class="hits">2</span>
2129
2303
 
2130
- <code class="ruby"> group = parse_single_char_group( parse_unicode_sequence($1) )</code>
2304
+ <code class="ruby"> group = parse_single_char_group(&#39;&#39;) # Ignore the &quot;illegal&quot; character</code>
2131
2305
  </li>
2132
2306
 
2133
- <li class="never" data-hits="" data-linenumber="67">
2307
+ <li class="never" data-hits="" data-linenumber="96">
2308
+
2309
+
2310
+ <code class="ruby"> else</code>
2311
+ </li>
2312
+
2313
+ <li class="covered" data-hits="2" data-linenumber="97">
2314
+ <span class="hits">2</span>
2315
+
2316
+ <code class="ruby"> raise IllegalSyntaxError, &quot;Anchors cannot be supported, as they are not regular&quot;</code>
2317
+ </li>
2318
+
2319
+ <li class="never" data-hits="" data-linenumber="98">
2320
+
2321
+
2322
+ <code class="ruby"> end</code>
2323
+ </li>
2324
+
2325
+ <li class="never" data-hits="" data-linenumber="99">
2134
2326
 
2135
2327
 
2136
2328
  <code class="ruby"> else</code>
2137
2329
  </li>
2138
2330
 
2139
- <li class="covered" data-hits="2" data-linenumber="68">
2331
+ <li class="covered" data-hits="2" data-linenumber="100">
2140
2332
  <span class="hits">2</span>
2141
2333
 
2142
2334
  <code class="ruby"> group = parse_single_char_group( regexp_string[@current_position] )</code>
2143
2335
  </li>
2144
2336
 
2145
- <li class="never" data-hits="" data-linenumber="69">
2337
+ <li class="never" data-hits="" data-linenumber="101">
2146
2338
 
2147
2339
 
2148
2340
  <code class="ruby"> # TODO: What about cases like \A, \z, \Z ?</code>
2149
2341
  </li>
2150
2342
 
2151
- <li class="covered" data-hits="49" data-linenumber="70">
2152
- <span class="hits">49</span>
2343
+ <li class="covered" data-hits="63" data-linenumber="102">
2344
+ <span class="hits">63</span>
2153
2345
 
2154
2346
  <code class="ruby"> end</code>
2155
2347
  </li>
2156
2348
 
2157
- <li class="covered" data-hits="49" data-linenumber="71">
2158
- <span class="hits">49</span>
2349
+ <li class="covered" data-hits="53" data-linenumber="103">
2350
+ <span class="hits">53</span>
2159
2351
 
2160
2352
  <code class="ruby"> group</code>
2161
2353
  </li>
2162
2354
 
2163
- <li class="never" data-hits="" data-linenumber="72">
2355
+ <li class="never" data-hits="" data-linenumber="104">
2164
2356
 
2165
2357
 
2166
2358
  <code class="ruby"> end</code>
2167
2359
  </li>
2168
2360
 
2169
- <li class="never" data-hits="" data-linenumber="73">
2361
+ <li class="never" data-hits="" data-linenumber="105">
2170
2362
 
2171
2363
 
2172
2364
  <code class="ruby"></code>
2173
2365
  </li>
2174
2366
 
2175
- <li class="covered" data-hits="1" data-linenumber="74">
2367
+ <li class="covered" data-hits="1" data-linenumber="106">
2176
2368
  <span class="hits">1</span>
2177
2369
 
2178
2370
  <code class="ruby"> def parse_repeater(group)</code>
2179
2371
  </li>
2180
2372
 
2181
- <li class="covered" data-hits="290" data-linenumber="75">
2182
- <span class="hits">290</span>
2373
+ <li class="covered" data-hits="360" data-linenumber="107">
2374
+ <span class="hits">360</span>
2183
2375
 
2184
2376
  <code class="ruby"> char = regexp_string[@current_position]</code>
2185
2377
  </li>
2186
2378
 
2187
- <li class="covered" data-hits="290" data-linenumber="76">
2188
- <span class="hits">290</span>
2379
+ <li class="covered" data-hits="360" data-linenumber="108">
2380
+ <span class="hits">360</span>
2189
2381
 
2190
2382
  <code class="ruby"> case char</code>
2191
2383
  </li>
2192
2384
 
2193
- <li class="never" data-hits="" data-linenumber="77">
2385
+ <li class="never" data-hits="" data-linenumber="109">
2194
2386
 
2195
2387
 
2196
2388
  <code class="ruby"> when &#39;*&#39;</code>
2197
2389
  </li>
2198
2390
 
2199
- <li class="covered" data-hits="5" data-linenumber="78">
2391
+ <li class="covered" data-hits="5" data-linenumber="110">
2200
2392
  <span class="hits">5</span>
2201
2393
 
2202
2394
  <code class="ruby"> repeater = parse_star_repeater(group)</code>
2203
2395
  </li>
2204
2396
 
2205
- <li class="never" data-hits="" data-linenumber="79">
2397
+ <li class="never" data-hits="" data-linenumber="111">
2206
2398
 
2207
2399
 
2208
2400
  <code class="ruby"> when &#39;+&#39;</code>
2209
2401
  </li>
2210
2402
 
2211
- <li class="covered" data-hits="4" data-linenumber="80">
2403
+ <li class="covered" data-hits="4" data-linenumber="112">
2212
2404
  <span class="hits">4</span>
2213
2405
 
2214
2406
  <code class="ruby"> repeater = parse_plus_repeater(group)</code>
2215
2407
  </li>
2216
2408
 
2217
- <li class="never" data-hits="" data-linenumber="81">
2409
+ <li class="never" data-hits="" data-linenumber="113">
2218
2410
 
2219
2411
 
2220
2412
  <code class="ruby"> when &#39;?&#39;</code>
2221
2413
  </li>
2222
2414
 
2223
- <li class="covered" data-hits="11" data-linenumber="82">
2415
+ <li class="covered" data-hits="11" data-linenumber="114">
2224
2416
  <span class="hits">11</span>
2225
2417
 
2226
2418
  <code class="ruby"> repeater = parse_question_mark_repeater(group)</code>
2227
2419
  </li>
2228
2420
 
2229
- <li class="never" data-hits="" data-linenumber="83">
2421
+ <li class="never" data-hits="" data-linenumber="115">
2230
2422
 
2231
2423
 
2232
2424
  <code class="ruby"> when &#39;{&#39;</code>
2233
2425
  </li>
2234
2426
 
2235
- <li class="covered" data-hits="5" data-linenumber="84">
2427
+ <li class="covered" data-hits="5" data-linenumber="116">
2236
2428
  <span class="hits">5</span>
2237
2429
 
2238
2430
  <code class="ruby"> repeater = parse_range_repeater(group)</code>
2239
2431
  </li>
2240
2432
 
2241
- <li class="never" data-hits="" data-linenumber="85">
2433
+ <li class="never" data-hits="" data-linenumber="117">
2242
2434
 
2243
2435
 
2244
2436
  <code class="ruby"> else</code>
2245
2437
  </li>
2246
2438
 
2247
- <li class="covered" data-hits="265" data-linenumber="86">
2248
- <span class="hits">265</span>
2439
+ <li class="covered" data-hits="335" data-linenumber="118">
2440
+ <span class="hits">335</span>
2249
2441
 
2250
2442
  <code class="ruby"> repeater = parse_one_time_repeater(group)</code>
2251
2443
  </li>
2252
2444
 
2253
- <li class="never" data-hits="" data-linenumber="87">
2445
+ <li class="never" data-hits="" data-linenumber="119">
2254
2446
 
2255
2447
 
2256
2448
  <code class="ruby"> end</code>
2257
2449
  </li>
2258
2450
 
2259
- <li class="covered" data-hits="290" data-linenumber="88">
2260
- <span class="hits">290</span>
2451
+ <li class="covered" data-hits="360" data-linenumber="120">
2452
+ <span class="hits">360</span>
2261
2453
 
2262
2454
  <code class="ruby"> repeater</code>
2263
2455
  </li>
2264
2456
 
2265
- <li class="never" data-hits="" data-linenumber="89">
2457
+ <li class="never" data-hits="" data-linenumber="121">
2266
2458
 
2267
2459
 
2268
2460
  <code class="ruby"> end</code>
2269
2461
  </li>
2270
2462
 
2271
- <li class="never" data-hits="" data-linenumber="90">
2463
+ <li class="never" data-hits="" data-linenumber="122">
2272
2464
 
2273
2465
 
2274
2466
  <code class="ruby"></code>
2275
2467
  </li>
2276
2468
 
2277
- <li class="covered" data-hits="1" data-linenumber="91">
2469
+ <li class="covered" data-hits="1" data-linenumber="123">
2278
2470
  <span class="hits">1</span>
2279
2471
 
2280
2472
  <code class="ruby"> def parse_multi_group</code>
2281
2473
  </li>
2282
2474
 
2283
- <li class="covered" data-hits="45" data-linenumber="92">
2284
- <span class="hits">45</span>
2475
+ <li class="covered" data-hits="46" data-linenumber="124">
2476
+ <span class="hits">46</span>
2285
2477
 
2286
2478
  <code class="ruby"> @current_position += 1</code>
2287
2479
  </li>
2288
2480
 
2289
- <li class="covered" data-hits="45" data-linenumber="93">
2290
- <span class="hits">45</span>
2481
+ <li class="covered" data-hits="46" data-linenumber="125">
2482
+ <span class="hits">46</span>
2291
2483
 
2292
2484
  <code class="ruby"> @num_groups += 1</code>
2293
2485
  </li>
2294
2486
 
2295
- <li class="covered" data-hits="45" data-linenumber="94">
2296
- <span class="hits">45</span>
2487
+ <li class="covered" data-hits="46" data-linenumber="126">
2488
+ <span class="hits">46</span>
2297
2489
 
2298
2490
  <code class="ruby"> group_id = nil # init</code>
2299
2491
  </li>
2300
2492
 
2301
- <li class="covered" data-hits="45" data-linenumber="95">
2302
- <span class="hits">45</span>
2493
+ <li class="covered" data-hits="46" data-linenumber="127">
2494
+ <span class="hits">46</span>
2303
2495
 
2304
2496
  <code class="ruby"> rest_of_string.match(/\A(\?)?(:|!|=|&lt;(!|=|[^!=][^&gt;]*))?/) do |match|</code>
2305
2497
  </li>
2306
2498
 
2307
- <li class="never" data-hits="" data-linenumber="96">
2499
+ <li class="never" data-hits="" data-linenumber="128">
2308
2500
 
2309
2501
 
2310
2502
  <code class="ruby"> case</code>
2311
2503
  </li>
2312
2504
 
2313
- <li class="never" data-hits="" data-linenumber="97">
2505
+ <li class="never" data-hits="" data-linenumber="129">
2314
2506
 
2315
2507
 
2316
2508
  <code class="ruby"> when match[1].nil? # e.g. /(normal)/</code>
2317
2509
  </li>
2318
2510
 
2319
- <li class="covered" data-hits="38" data-linenumber="98">
2511
+ <li class="covered" data-hits="38" data-linenumber="130">
2320
2512
  <span class="hits">38</span>
2321
2513
 
2322
2514
  <code class="ruby"> group_id = @num_groups.to_s</code>
2323
2515
  </li>
2324
2516
 
2325
- <li class="never" data-hits="" data-linenumber="99">
2517
+ <li class="never" data-hits="" data-linenumber="131">
2326
2518
 
2327
2519
 
2328
2520
  <code class="ruby"> when match[2] == &#39;:&#39; # e.g. /(?:nocapture)/</code>
2329
2521
  </li>
2330
2522
 
2331
- <li class="covered" data-hits="1" data-linenumber="100">
2523
+ <li class="covered" data-hits="1" data-linenumber="132">
2332
2524
  <span class="hits">1</span>
2333
2525
 
2334
2526
  <code class="ruby"> @current_position += 2</code>
2335
2527
  </li>
2336
2528
 
2337
- <li class="covered" data-hits="1" data-linenumber="101">
2529
+ <li class="covered" data-hits="1" data-linenumber="133">
2338
2530
  <span class="hits">1</span>
2339
2531
 
2340
2532
  <code class="ruby"> group_id = nil</code>
2341
2533
  </li>
2342
2534
 
2343
- <li class="never" data-hits="" data-linenumber="102">
2535
+ <li class="never" data-hits="" data-linenumber="134">
2344
2536
 
2345
2537
 
2346
2538
  <code class="ruby"> when %w(! =).include?(match[2]) # e.g. /(?=lookahead)/, /(?!neglookahead)/</code>
2347
2539
  </li>
2348
2540
 
2349
- <li class="covered" data-hits="2" data-linenumber="103">
2541
+ <li class="covered" data-hits="2" data-linenumber="135">
2350
2542
  <span class="hits">2</span>
2351
2543
 
2352
2544
  <code class="ruby"> raise IllegalSyntaxError, &quot;Lookaheads are not regular; cannot generate examples&quot;</code>
2353
2545
  </li>
2354
2546
 
2355
- <li class="never" data-hits="" data-linenumber="104">
2547
+ <li class="never" data-hits="" data-linenumber="136">
2356
2548
 
2357
2549
 
2358
2550
  <code class="ruby"> when %w(! =).include?(match[3]) # e.g. /(?&lt;=lookbehind)/, /(?&lt;!neglookbehind)/</code>
2359
2551
  </li>
2360
2552
 
2361
- <li class="covered" data-hits="2" data-linenumber="105">
2553
+ <li class="covered" data-hits="2" data-linenumber="137">
2362
2554
  <span class="hits">2</span>
2363
2555
 
2364
2556
  <code class="ruby"> raise IllegalSyntaxError, &quot;Lookbehinds are not regular; cannot generate examples&quot;</code>
2365
2557
  </li>
2366
2558
 
2367
- <li class="never" data-hits="" data-linenumber="106">
2559
+ <li class="never" data-hits="" data-linenumber="138">
2368
2560
 
2369
2561
 
2370
2562
  <code class="ruby"> else # e.g. /(?&lt;name&gt;namedgroup)/</code>
2371
2563
  </li>
2372
2564
 
2373
- <li class="covered" data-hits="2" data-linenumber="107">
2374
- <span class="hits">2</span>
2565
+ <li class="covered" data-hits="3" data-linenumber="139">
2566
+ <span class="hits">3</span>
2375
2567
 
2376
2568
  <code class="ruby"> @current_position += (match[3].length + 3)</code>
2377
2569
  </li>
2378
2570
 
2379
- <li class="covered" data-hits="2" data-linenumber="108">
2380
- <span class="hits">2</span>
2571
+ <li class="covered" data-hits="3" data-linenumber="140">
2572
+ <span class="hits">3</span>
2381
2573
 
2382
2574
  <code class="ruby"> group_id = match[3]</code>
2383
2575
  </li>
2384
2576
 
2385
- <li class="covered" data-hits="45" data-linenumber="109">
2386
- <span class="hits">45</span>
2577
+ <li class="covered" data-hits="46" data-linenumber="141">
2578
+ <span class="hits">46</span>
2387
2579
 
2388
2580
  <code class="ruby"> end</code>
2389
2581
  </li>
2390
2582
 
2391
- <li class="never" data-hits="" data-linenumber="110">
2583
+ <li class="never" data-hits="" data-linenumber="142">
2392
2584
 
2393
2585
 
2394
2586
  <code class="ruby"> end</code>
2395
2587
  </li>
2396
2588
 
2397
- <li class="covered" data-hits="41" data-linenumber="111">
2398
- <span class="hits">41</span>
2589
+ <li class="covered" data-hits="42" data-linenumber="143">
2590
+ <span class="hits">42</span>
2399
2591
 
2400
2592
  <code class="ruby"> groups = parse</code>
2401
2593
  </li>
2402
2594
 
2403
- <li class="covered" data-hits="41" data-linenumber="112">
2595
+ <li class="covered" data-hits="41" data-linenumber="144">
2404
2596
  <span class="hits">41</span>
2405
2597
 
2406
2598
  <code class="ruby"> MultiGroup.new(groups, group_id)</code>
2407
2599
  </li>
2408
2600
 
2409
- <li class="never" data-hits="" data-linenumber="113">
2601
+ <li class="never" data-hits="" data-linenumber="145">
2410
2602
 
2411
2603
 
2412
2604
  <code class="ruby"> end</code>
2413
2605
  </li>
2414
2606
 
2415
- <li class="never" data-hits="" data-linenumber="114">
2607
+ <li class="never" data-hits="" data-linenumber="146">
2416
2608
 
2417
2609
 
2418
2610
  <code class="ruby"></code>
2419
2611
  </li>
2420
2612
 
2421
- <li class="covered" data-hits="1" data-linenumber="115">
2613
+ <li class="covered" data-hits="1" data-linenumber="147">
2422
2614
  <span class="hits">1</span>
2423
2615
 
2424
2616
  <code class="ruby"> def parse_multi_end_group</code>
2425
2617
  </li>
2426
2618
 
2427
- <li class="covered" data-hits="41" data-linenumber="116">
2619
+ <li class="covered" data-hits="41" data-linenumber="148">
2428
2620
  <span class="hits">41</span>
2429
2621
 
2430
2622
  <code class="ruby"> MultiGroupEnd.new</code>
2431
2623
  </li>
2432
2624
 
2433
- <li class="never" data-hits="" data-linenumber="117">
2625
+ <li class="never" data-hits="" data-linenumber="149">
2434
2626
 
2435
2627
 
2436
2628
  <code class="ruby"> end</code>
2437
2629
  </li>
2438
2630
 
2439
- <li class="never" data-hits="" data-linenumber="118">
2631
+ <li class="never" data-hits="" data-linenumber="150">
2440
2632
 
2441
2633
 
2442
2634
  <code class="ruby"></code>
2443
2635
  </li>
2444
2636
 
2445
- <li class="covered" data-hits="1" data-linenumber="119">
2637
+ <li class="covered" data-hits="1" data-linenumber="151">
2446
2638
  <span class="hits">1</span>
2447
2639
 
2448
2640
  <code class="ruby"> def parse_char_group</code>
2449
2641
  </li>
2450
2642
 
2451
- <li class="covered" data-hits="14" data-linenumber="120">
2452
- <span class="hits">14</span>
2643
+ <li class="covered" data-hits="15" data-linenumber="152">
2644
+ <span class="hits">15</span>
2453
2645
 
2454
- <code class="ruby"> chars = []</code>
2646
+ <code class="ruby"> if rest_of_string =~ /\A\[\[:[^:]+:\]\]/</code>
2455
2647
  </li>
2456
2648
 
2457
- <li class="covered" data-hits="14" data-linenumber="121">
2458
- <span class="hits">14</span>
2649
+ <li class="covered" data-hits="1" data-linenumber="153">
2650
+ <span class="hits">1</span>
2651
+
2652
+ <code class="ruby"> raise UnsupportedSyntaxError, &quot;POSIX bracket expressions are not yet implemented&quot;</code>
2653
+ </li>
2654
+
2655
+ <li class="never" data-hits="" data-linenumber="154">
2656
+
2657
+
2658
+ <code class="ruby"> end</code>
2659
+ </li>
2660
+
2661
+ <li class="covered" data-hits="14" data-linenumber="155">
2662
+ <span class="hits">14</span>
2663
+
2664
+ <code class="ruby"> chars = []</code>
2665
+ </li>
2666
+
2667
+ <li class="covered" data-hits="14" data-linenumber="156">
2668
+ <span class="hits">14</span>
2459
2669
 
2460
2670
  <code class="ruby"> @current_position += 1</code>
2461
2671
  </li>
2462
2672
 
2463
- <li class="covered" data-hits="14" data-linenumber="122">
2673
+ <li class="covered" data-hits="14" data-linenumber="157">
2464
2674
  <span class="hits">14</span>
2465
2675
 
2466
2676
  <code class="ruby"> if regexp_string[@current_position] == &#39;]&#39;</code>
2467
2677
  </li>
2468
2678
 
2469
- <li class="never" data-hits="" data-linenumber="123">
2679
+ <li class="never" data-hits="" data-linenumber="158">
2470
2680
 
2471
2681
 
2472
2682
  <code class="ruby"> # Beware of the sneaky edge case:</code>
2473
2683
  </li>
2474
2684
 
2475
- <li class="never" data-hits="" data-linenumber="124">
2685
+ <li class="never" data-hits="" data-linenumber="159">
2476
2686
 
2477
2687
 
2478
2688
  <code class="ruby"> # /[]]/ (match &quot;]&quot;)</code>
2479
2689
  </li>
2480
2690
 
2481
- <li class="covered" data-hits="1" data-linenumber="125">
2691
+ <li class="covered" data-hits="1" data-linenumber="160">
2482
2692
  <span class="hits">1</span>
2483
2693
 
2484
2694
  <code class="ruby"> chars &lt;&lt; &#39;]&#39;</code>
2485
2695
  </li>
2486
2696
 
2487
- <li class="covered" data-hits="1" data-linenumber="126">
2697
+ <li class="covered" data-hits="1" data-linenumber="161">
2488
2698
  <span class="hits">1</span>
2489
2699
 
2490
2700
  <code class="ruby"> @current_position += 1</code>
2491
2701
  </li>
2492
2702
 
2493
- <li class="never" data-hits="" data-linenumber="127">
2703
+ <li class="never" data-hits="" data-linenumber="162">
2494
2704
 
2495
2705
 
2496
2706
  <code class="ruby"> end</code>
2497
2707
  </li>
2498
2708
 
2499
- <li class="never" data-hits="" data-linenumber="128">
2709
+ <li class="never" data-hits="" data-linenumber="163">
2500
2710
 
2501
2711
 
2502
2712
  <code class="ruby"> until regexp_string[@current_position] == &#39;]&#39; \</code>
2503
2713
  </li>
2504
2714
 
2505
- <li class="covered" data-hits="14" data-linenumber="129">
2715
+ <li class="covered" data-hits="14" data-linenumber="164">
2506
2716
  <span class="hits">14</span>
2507
2717
 
2508
2718
  <code class="ruby"> &amp;&amp; !regexp_string[0..@current_position-1].match(/[^\\](\\{2})*\\\z/)</code>
2509
2719
  </li>
2510
2720
 
2511
- <li class="never" data-hits="" data-linenumber="130">
2721
+ <li class="never" data-hits="" data-linenumber="165">
2512
2722
 
2513
2723
 
2514
2724
  <code class="ruby"> # Beware of having an ODD number of &quot;\&quot; before the &quot;]&quot;, e.g.</code>
2515
2725
  </li>
2516
2726
 
2517
- <li class="never" data-hits="" data-linenumber="131">
2727
+ <li class="never" data-hits="" data-linenumber="166">
2518
2728
 
2519
2729
 
2520
2730
  <code class="ruby"> # /[\]]/ (match &quot;]&quot;)</code>
2521
2731
  </li>
2522
2732
 
2523
- <li class="never" data-hits="" data-linenumber="132">
2733
+ <li class="never" data-hits="" data-linenumber="167">
2524
2734
 
2525
2735
 
2526
2736
  <code class="ruby"> # /[\\]/ (match &quot;\&quot;)</code>
2527
2737
  </li>
2528
2738
 
2529
- <li class="never" data-hits="" data-linenumber="133">
2739
+ <li class="never" data-hits="" data-linenumber="168">
2530
2740
 
2531
2741
 
2532
2742
  <code class="ruby"> # /[\\\]]/ (match &quot;\&quot; or &quot;]&quot;)</code>
2533
2743
  </li>
2534
2744
 
2535
- <li class="covered" data-hits="41" data-linenumber="134">
2745
+ <li class="covered" data-hits="41" data-linenumber="169">
2536
2746
  <span class="hits">41</span>
2537
2747
 
2538
2748
  <code class="ruby"> chars &lt;&lt; regexp_string[@current_position]</code>
2539
2749
  </li>
2540
2750
 
2541
- <li class="covered" data-hits="41" data-linenumber="135">
2751
+ <li class="covered" data-hits="41" data-linenumber="170">
2542
2752
  <span class="hits">41</span>
2543
2753
 
2544
2754
  <code class="ruby"> @current_position += 1</code>
2545
2755
  </li>
2546
2756
 
2547
- <li class="never" data-hits="" data-linenumber="136">
2757
+ <li class="never" data-hits="" data-linenumber="171">
2548
2758
 
2549
2759
 
2550
2760
  <code class="ruby"> end</code>
2551
2761
  </li>
2552
2762
 
2553
- <li class="covered" data-hits="14" data-linenumber="137">
2763
+ <li class="covered" data-hits="14" data-linenumber="172">
2554
2764
  <span class="hits">14</span>
2555
2765
 
2556
2766
  <code class="ruby"> CharGroup.new(chars)</code>
2557
2767
  </li>
2558
2768
 
2559
- <li class="never" data-hits="" data-linenumber="138">
2769
+ <li class="never" data-hits="" data-linenumber="173">
2560
2770
 
2561
2771
 
2562
2772
  <code class="ruby"> end</code>
2563
2773
  </li>
2564
2774
 
2565
- <li class="never" data-hits="" data-linenumber="139">
2775
+ <li class="never" data-hits="" data-linenumber="174">
2566
2776
 
2567
2777
 
2568
2778
  <code class="ruby"></code>
2569
2779
  </li>
2570
2780
 
2571
- <li class="covered" data-hits="1" data-linenumber="140">
2781
+ <li class="covered" data-hits="1" data-linenumber="175">
2572
2782
  <span class="hits">1</span>
2573
2783
 
2574
2784
  <code class="ruby"> def parse_dot_group</code>
2575
2785
  </li>
2576
2786
 
2577
- <li class="covered" data-hits="1" data-linenumber="141">
2578
- <span class="hits">1</span>
2787
+ <li class="covered" data-hits="4" data-linenumber="176">
2788
+ <span class="hits">4</span>
2579
2789
 
2580
2790
  <code class="ruby"> DotGroup.new</code>
2581
2791
  </li>
2582
2792
 
2583
- <li class="never" data-hits="" data-linenumber="142">
2793
+ <li class="never" data-hits="" data-linenumber="177">
2584
2794
 
2585
2795
 
2586
2796
  <code class="ruby"> end</code>
2587
2797
  </li>
2588
2798
 
2589
- <li class="never" data-hits="" data-linenumber="143">
2799
+ <li class="never" data-hits="" data-linenumber="178">
2590
2800
 
2591
2801
 
2592
2802
  <code class="ruby"></code>
2593
2803
  </li>
2594
2804
 
2595
- <li class="covered" data-hits="1" data-linenumber="144">
2805
+ <li class="covered" data-hits="1" data-linenumber="179">
2596
2806
  <span class="hits">1</span>
2597
2807
 
2598
2808
  <code class="ruby"> def parse_or_group(left_repeaters)</code>
2599
2809
  </li>
2600
2810
 
2601
- <li class="covered" data-hits="6" data-linenumber="145">
2811
+ <li class="covered" data-hits="6" data-linenumber="180">
2602
2812
  <span class="hits">6</span>
2603
2813
 
2604
2814
  <code class="ruby"> @current_position += 1</code>
2605
2815
  </li>
2606
2816
 
2607
- <li class="covered" data-hits="6" data-linenumber="146">
2817
+ <li class="covered" data-hits="6" data-linenumber="181">
2608
2818
  <span class="hits">6</span>
2609
2819
 
2610
2820
  <code class="ruby"> right_repeaters = parse</code>
2611
2821
  </li>
2612
2822
 
2613
- <li class="covered" data-hits="6" data-linenumber="147">
2823
+ <li class="covered" data-hits="6" data-linenumber="182">
2614
2824
  <span class="hits">6</span>
2615
2825
 
2616
2826
  <code class="ruby"> OrGroup.new(left_repeaters, right_repeaters)</code>
2617
2827
  </li>
2618
2828
 
2619
- <li class="never" data-hits="" data-linenumber="148">
2829
+ <li class="never" data-hits="" data-linenumber="183">
2620
2830
 
2621
2831
 
2622
2832
  <code class="ruby"> end</code>
2623
2833
  </li>
2624
2834
 
2625
- <li class="never" data-hits="" data-linenumber="149">
2835
+ <li class="never" data-hits="" data-linenumber="184">
2626
2836
 
2627
2837
 
2628
2838
  <code class="ruby"></code>
2629
2839
  </li>
2630
2840
 
2631
- <li class="never" data-hits="" data-linenumber="150">
2841
+ <li class="never" data-hits="" data-linenumber="185">
2632
2842
 
2633
2843
 
2634
2844
  <code class="ruby"></code>
2635
2845
  </li>
2636
2846
 
2637
- <li class="covered" data-hits="1" data-linenumber="151">
2847
+ <li class="covered" data-hits="1" data-linenumber="186">
2638
2848
  <span class="hits">1</span>
2639
2849
 
2640
2850
  <code class="ruby"> def parse_single_char_group(char)</code>
2641
2851
  </li>
2642
2852
 
2643
- <li class="covered" data-hits="194" data-linenumber="152">
2644
- <span class="hits">194</span>
2853
+ <li class="covered" data-hits="261" data-linenumber="187">
2854
+ <span class="hits">261</span>
2645
2855
 
2646
2856
  <code class="ruby"> SingleCharGroup.new(char)</code>
2647
2857
  </li>
2648
2858
 
2649
- <li class="never" data-hits="" data-linenumber="153">
2859
+ <li class="never" data-hits="" data-linenumber="188">
2650
2860
 
2651
2861
 
2652
2862
  <code class="ruby"> end</code>
2653
2863
  </li>
2654
2864
 
2655
- <li class="never" data-hits="" data-linenumber="154">
2865
+ <li class="never" data-hits="" data-linenumber="189">
2656
2866
 
2657
2867
 
2658
2868
  <code class="ruby"></code>
2659
2869
  </li>
2660
2870
 
2661
- <li class="covered" data-hits="1" data-linenumber="155">
2871
+ <li class="covered" data-hits="1" data-linenumber="190">
2662
2872
  <span class="hits">1</span>
2663
2873
 
2664
2874
  <code class="ruby"> def parse_backreference_group(match)</code>
2665
2875
  </li>
2666
2876
 
2667
- <li class="covered" data-hits="20" data-linenumber="156">
2877
+ <li class="covered" data-hits="20" data-linenumber="191">
2668
2878
  <span class="hits">20</span>
2669
2879
 
2670
2880
  <code class="ruby"> BackReferenceGroup.new(match)</code>
2671
2881
  </li>
2672
2882
 
2673
- <li class="never" data-hits="" data-linenumber="157">
2883
+ <li class="never" data-hits="" data-linenumber="192">
2674
2884
 
2675
2885
 
2676
2886
  <code class="ruby"> end</code>
2677
2887
  </li>
2678
2888
 
2679
- <li class="never" data-hits="" data-linenumber="158">
2889
+ <li class="never" data-hits="" data-linenumber="193">
2680
2890
 
2681
2891
 
2682
2892
  <code class="ruby"></code>
2683
2893
  </li>
2684
2894
 
2685
- <li class="covered" data-hits="1" data-linenumber="159">
2895
+ <li class="covered" data-hits="1" data-linenumber="194">
2686
2896
  <span class="hits">1</span>
2687
2897
 
2688
2898
  <code class="ruby"> def parse_control_character(char)</code>
2689
2899
  </li>
2690
2900
 
2691
- <li class="covered" data-hits="8" data-linenumber="160">
2901
+ <li class="covered" data-hits="8" data-linenumber="195">
2692
2902
  <span class="hits">8</span>
2693
2903
 
2694
2904
  <code class="ruby"> (char.ord % 32).chr # Black magic!</code>
2695
2905
  </li>
2696
2906
 
2697
- <li class="never" data-hits="" data-linenumber="161">
2907
+ <li class="never" data-hits="" data-linenumber="196">
2698
2908
 
2699
2909
 
2700
2910
  <code class="ruby"> # eval &quot;?\\C-#{char.chr}&quot; # Doesn&#39;t work for e.g. char = &quot;?&quot;</code>
2701
2911
  </li>
2702
2912
 
2703
- <li class="never" data-hits="" data-linenumber="162">
2913
+ <li class="never" data-hits="" data-linenumber="197">
2704
2914
 
2705
2915
 
2706
2916
  <code class="ruby"> end</code>
2707
2917
  </li>
2708
2918
 
2709
- <li class="never" data-hits="" data-linenumber="163">
2919
+ <li class="never" data-hits="" data-linenumber="198">
2710
2920
 
2711
2921
 
2712
2922
  <code class="ruby"></code>
2713
2923
  </li>
2714
2924
 
2715
- <li class="covered" data-hits="1" data-linenumber="164">
2925
+ <li class="covered" data-hits="1" data-linenumber="199">
2716
2926
  <span class="hits">1</span>
2717
2927
 
2718
2928
  <code class="ruby"> def parse_escape_sequence(match)</code>
2719
2929
  </li>
2720
2930
 
2721
- <li class="covered" data-hits="3" data-linenumber="165">
2931
+ <li class="covered" data-hits="3" data-linenumber="200">
2722
2932
  <span class="hits">3</span>
2723
2933
 
2724
2934
  <code class="ruby"> eval &quot;?\\x#{match}&quot;</code>
2725
2935
  </li>
2726
2936
 
2727
- <li class="never" data-hits="" data-linenumber="166">
2937
+ <li class="never" data-hits="" data-linenumber="201">
2728
2938
 
2729
2939
 
2730
2940
  <code class="ruby"> end</code>
2731
2941
  </li>
2732
2942
 
2733
- <li class="never" data-hits="" data-linenumber="167">
2943
+ <li class="never" data-hits="" data-linenumber="202">
2734
2944
 
2735
2945
 
2736
2946
  <code class="ruby"></code>
2737
2947
  </li>
2738
2948
 
2739
- <li class="covered" data-hits="1" data-linenumber="168">
2949
+ <li class="covered" data-hits="1" data-linenumber="203">
2740
2950
  <span class="hits">1</span>
2741
2951
 
2742
2952
  <code class="ruby"> def parse_unicode_sequence(match)</code>
2743
2953
  </li>
2744
2954
 
2745
- <li class="covered" data-hits="2" data-linenumber="169">
2746
- <span class="hits">2</span>
2955
+ <li class="covered" data-hits="3" data-linenumber="204">
2956
+ <span class="hits">3</span>
2747
2957
 
2748
- <code class="ruby"> eval &quot;?\\u#{match}&quot;</code>
2958
+ <code class="ruby"> eval &quot;?\\u{#{match}}&quot;</code>
2749
2959
  </li>
2750
2960
 
2751
- <li class="never" data-hits="" data-linenumber="170">
2961
+ <li class="never" data-hits="" data-linenumber="205">
2752
2962
 
2753
2963
 
2754
2964
  <code class="ruby"> end</code>
2755
2965
  </li>
2756
2966
 
2757
- <li class="never" data-hits="" data-linenumber="171">
2967
+ <li class="never" data-hits="" data-linenumber="206">
2758
2968
 
2759
2969
 
2760
2970
  <code class="ruby"></code>
2761
2971
  </li>
2762
2972
 
2763
- <li class="covered" data-hits="1" data-linenumber="172">
2973
+ <li class="covered" data-hits="1" data-linenumber="207">
2764
2974
  <span class="hits">1</span>
2765
2975
 
2766
2976
  <code class="ruby"> def parse_star_repeater(group)</code>
2767
2977
  </li>
2768
2978
 
2769
- <li class="covered" data-hits="5" data-linenumber="173">
2979
+ <li class="covered" data-hits="5" data-linenumber="208">
2770
2980
  <span class="hits">5</span>
2771
2981
 
2772
2982
  <code class="ruby"> @current_position += 1</code>
2773
2983
  </li>
2774
2984
 
2775
- <li class="covered" data-hits="5" data-linenumber="174">
2985
+ <li class="covered" data-hits="5" data-linenumber="209">
2776
2986
  <span class="hits">5</span>
2777
2987
 
2778
2988
  <code class="ruby"> StarRepeater.new(group)</code>
2779
2989
  </li>
2780
2990
 
2781
- <li class="never" data-hits="" data-linenumber="175">
2991
+ <li class="never" data-hits="" data-linenumber="210">
2782
2992
 
2783
2993
 
2784
2994
  <code class="ruby"> end</code>
2785
2995
  </li>
2786
2996
 
2787
- <li class="never" data-hits="" data-linenumber="176">
2997
+ <li class="never" data-hits="" data-linenumber="211">
2788
2998
 
2789
2999
 
2790
3000
  <code class="ruby"></code>
2791
3001
  </li>
2792
3002
 
2793
- <li class="covered" data-hits="1" data-linenumber="177">
3003
+ <li class="covered" data-hits="1" data-linenumber="212">
2794
3004
  <span class="hits">1</span>
2795
3005
 
2796
3006
  <code class="ruby"> def parse_plus_repeater(group)</code>
2797
3007
  </li>
2798
3008
 
2799
- <li class="covered" data-hits="4" data-linenumber="178">
3009
+ <li class="covered" data-hits="4" data-linenumber="213">
2800
3010
  <span class="hits">4</span>
2801
3011
 
2802
3012
  <code class="ruby"> @current_position += 1</code>
2803
3013
  </li>
2804
3014
 
2805
- <li class="covered" data-hits="4" data-linenumber="179">
3015
+ <li class="covered" data-hits="4" data-linenumber="214">
2806
3016
  <span class="hits">4</span>
2807
3017
 
2808
3018
  <code class="ruby"> PlusRepeater.new(group)</code>
2809
3019
  </li>
2810
3020
 
2811
- <li class="never" data-hits="" data-linenumber="180">
3021
+ <li class="never" data-hits="" data-linenumber="215">
2812
3022
 
2813
3023
 
2814
3024
  <code class="ruby"> end</code>
2815
3025
  </li>
2816
3026
 
2817
- <li class="never" data-hits="" data-linenumber="181">
3027
+ <li class="never" data-hits="" data-linenumber="216">
2818
3028
 
2819
3029
 
2820
3030
  <code class="ruby"></code>
2821
3031
  </li>
2822
3032
 
2823
- <li class="covered" data-hits="1" data-linenumber="182">
3033
+ <li class="covered" data-hits="1" data-linenumber="217">
2824
3034
  <span class="hits">1</span>
2825
3035
 
2826
3036
  <code class="ruby"> def parse_question_mark_repeater(group)</code>
2827
3037
  </li>
2828
3038
 
2829
- <li class="covered" data-hits="11" data-linenumber="183">
3039
+ <li class="covered" data-hits="11" data-linenumber="218">
2830
3040
  <span class="hits">11</span>
2831
3041
 
2832
3042
  <code class="ruby"> @current_position += 1</code>
2833
3043
  </li>
2834
3044
 
2835
- <li class="covered" data-hits="11" data-linenumber="184">
3045
+ <li class="covered" data-hits="11" data-linenumber="219">
2836
3046
  <span class="hits">11</span>
2837
3047
 
2838
3048
  <code class="ruby"> QuestionMarkRepeater.new(group)</code>
2839
3049
  </li>
2840
3050
 
2841
- <li class="never" data-hits="" data-linenumber="185">
3051
+ <li class="never" data-hits="" data-linenumber="220">
2842
3052
 
2843
3053
 
2844
3054
  <code class="ruby"> end</code>
2845
3055
  </li>
2846
3056
 
2847
- <li class="never" data-hits="" data-linenumber="186">
3057
+ <li class="never" data-hits="" data-linenumber="221">
2848
3058
 
2849
3059
 
2850
3060
  <code class="ruby"></code>
2851
3061
  </li>
2852
3062
 
2853
- <li class="covered" data-hits="1" data-linenumber="187">
3063
+ <li class="covered" data-hits="1" data-linenumber="222">
2854
3064
  <span class="hits">1</span>
2855
3065
 
2856
3066
  <code class="ruby"> def parse_range_repeater(group)</code>
2857
3067
  </li>
2858
3068
 
2859
- <li class="covered" data-hits="5" data-linenumber="188">
3069
+ <li class="covered" data-hits="5" data-linenumber="223">
2860
3070
  <span class="hits">5</span>
2861
3071
 
2862
3072
  <code class="ruby"> match = rest_of_string.match(/\A\{(\d+)?(,)?(\d+)?\}/)</code>
2863
3073
  </li>
2864
3074
 
2865
- <li class="covered" data-hits="5" data-linenumber="189">
3075
+ <li class="covered" data-hits="5" data-linenumber="224">
2866
3076
  <span class="hits">5</span>
2867
3077
 
2868
3078
  <code class="ruby"> @current_position += match[0].size</code>
2869
3079
  </li>
2870
3080
 
2871
- <li class="covered" data-hits="5" data-linenumber="190">
3081
+ <li class="covered" data-hits="5" data-linenumber="225">
2872
3082
  <span class="hits">5</span>
2873
3083
 
2874
3084
  <code class="ruby"> min = match[1].to_i if match[1]</code>
2875
3085
  </li>
2876
3086
 
2877
- <li class="covered" data-hits="5" data-linenumber="191">
3087
+ <li class="covered" data-hits="5" data-linenumber="226">
2878
3088
  <span class="hits">5</span>
2879
3089
 
2880
3090
  <code class="ruby"> has_comma = !match[2].nil?</code>
2881
3091
  </li>
2882
3092
 
2883
- <li class="covered" data-hits="5" data-linenumber="192">
3093
+ <li class="covered" data-hits="5" data-linenumber="227">
2884
3094
  <span class="hits">5</span>
2885
3095
 
2886
3096
  <code class="ruby"> max = match[3].to_i if match[3]</code>
2887
3097
  </li>
2888
3098
 
2889
- <li class="covered" data-hits="5" data-linenumber="193">
3099
+ <li class="covered" data-hits="5" data-linenumber="228">
2890
3100
  <span class="hits">5</span>
2891
3101
 
2892
3102
  <code class="ruby"> RangeRepeater.new(group, min, has_comma, max)</code>
2893
3103
  </li>
2894
3104
 
2895
- <li class="never" data-hits="" data-linenumber="194">
3105
+ <li class="never" data-hits="" data-linenumber="229">
2896
3106
 
2897
3107
 
2898
3108
  <code class="ruby"> end</code>
2899
3109
  </li>
2900
3110
 
2901
- <li class="never" data-hits="" data-linenumber="195">
3111
+ <li class="never" data-hits="" data-linenumber="230">
2902
3112
 
2903
3113
 
2904
3114
  <code class="ruby"></code>
2905
3115
  </li>
2906
3116
 
2907
- <li class="covered" data-hits="1" data-linenumber="196">
3117
+ <li class="covered" data-hits="1" data-linenumber="231">
2908
3118
  <span class="hits">1</span>
2909
3119
 
2910
3120
  <code class="ruby"> def parse_one_time_repeater(group)</code>
2911
3121
  </li>
2912
3122
 
2913
- <li class="covered" data-hits="265" data-linenumber="197">
2914
- <span class="hits">265</span>
3123
+ <li class="covered" data-hits="335" data-linenumber="232">
3124
+ <span class="hits">335</span>
2915
3125
 
2916
3126
  <code class="ruby"> OneTimeRepeater.new(group)</code>
2917
3127
  </li>
2918
3128
 
2919
- <li class="never" data-hits="" data-linenumber="198">
3129
+ <li class="never" data-hits="" data-linenumber="233">
2920
3130
 
2921
3131
 
2922
3132
  <code class="ruby"> end</code>
2923
3133
  </li>
2924
3134
 
2925
- <li class="never" data-hits="" data-linenumber="199">
3135
+ <li class="never" data-hits="" data-linenumber="234">
2926
3136
 
2927
3137
 
2928
3138
  <code class="ruby"></code>
2929
3139
  </li>
2930
3140
 
2931
- <li class="covered" data-hits="1" data-linenumber="200">
3141
+ <li class="covered" data-hits="1" data-linenumber="235">
2932
3142
  <span class="hits">1</span>
2933
3143
 
2934
3144
  <code class="ruby"> def rest_of_string</code>
2935
3145
  </li>
2936
3146
 
2937
- <li class="covered" data-hits="155" data-linenumber="201">
2938
- <span class="hits">155</span>
3147
+ <li class="covered" data-hits="293" data-linenumber="236">
3148
+ <span class="hits">293</span>
2939
3149
 
2940
3150
  <code class="ruby"> regexp_string[@current_position..-1]</code>
2941
3151
  </li>
2942
3152
 
2943
- <li class="never" data-hits="" data-linenumber="202">
3153
+ <li class="never" data-hits="" data-linenumber="237">
2944
3154
 
2945
3155
 
2946
3156
  <code class="ruby"> end</code>
2947
3157
  </li>
2948
3158
 
2949
- <li class="never" data-hits="" data-linenumber="203">
3159
+ <li class="never" data-hits="" data-linenumber="238">
2950
3160
 
2951
3161
 
2952
3162
  <code class="ruby"> end</code>
2953
3163
  </li>
2954
3164
 
2955
- <li class="never" data-hits="" data-linenumber="204">
3165
+ <li class="never" data-hits="" data-linenumber="239">
2956
3166
 
2957
3167
 
2958
3168
  <code class="ruby">end</code>
2959
3169
  </li>
2960
3170
 
2961
- <li class="never" data-hits="" data-linenumber="205">
3171
+ <li class="never" data-hits="" data-linenumber="240">
2962
3172
 
2963
3173
 
2964
3174
  <code class="ruby"></code>
@@ -3000,8 +3210,8 @@
3000
3210
  <code class="ruby"> def examples</code>
3001
3211
  </li>
3002
3212
 
3003
- <li class="covered" data-hits="73" data-linenumber="4">
3004
- <span class="hits">73</span>
3213
+ <li class="covered" data-hits="92" data-linenumber="4">
3214
+ <span class="hits">92</span>
3005
3215
 
3006
3216
  <code class="ruby"> partial_examples =</code>
3007
3217
  </li>
@@ -3018,20 +3228,20 @@
3018
3228
  <code class="ruby"> .parse</code>
3019
3229
  </li>
3020
3230
 
3021
- <li class="covered" data-hits="133" data-linenumber="7">
3022
- <span class="hits">133</span>
3231
+ <li class="covered" data-hits="162" data-linenumber="7">
3232
+ <span class="hits">162</span>
3023
3233
 
3024
3234
  <code class="ruby"> .map {|repeater| repeater.result}</code>
3025
3235
  </li>
3026
3236
 
3027
- <li class="covered" data-hits="69" data-linenumber="8">
3028
- <span class="hits">69</span>
3237
+ <li class="covered" data-hits="75" data-linenumber="8">
3238
+ <span class="hits">75</span>
3029
3239
 
3030
3240
  <code class="ruby"> full_examples = RegexpExamples::permutations_of_strings(partial_examples)</code>
3031
3241
  </li>
3032
3242
 
3033
- <li class="covered" data-hits="69" data-linenumber="9">
3034
- <span class="hits">69</span>
3243
+ <li class="covered" data-hits="75" data-linenumber="9">
3244
+ <span class="hits">75</span>
3035
3245
 
3036
3246
  <code class="ruby"> RegexpExamples::BackReferenceReplacer.new.substitute_backreferences(full_examples)</code>
3037
3247
  </li>
@@ -3108,8 +3318,8 @@
3108
3318
  <code class="ruby"> def initialize(group)</code>
3109
3319
  </li>
3110
3320
 
3111
- <li class="covered" data-hits="290" data-linenumber="5">
3112
- <span class="hits">290</span>
3321
+ <li class="covered" data-hits="360" data-linenumber="5">
3322
+ <span class="hits">360</span>
3113
3323
 
3114
3324
  <code class="ruby"> @group = group</code>
3115
3325
  </li>
@@ -3132,32 +3342,32 @@
3132
3342
  <code class="ruby"> def result(min_repeats, max_repeats)</code>
3133
3343
  </li>
3134
3344
 
3135
- <li class="covered" data-hits="290" data-linenumber="9">
3136
- <span class="hits">290</span>
3345
+ <li class="covered" data-hits="319" data-linenumber="9">
3346
+ <span class="hits">319</span>
3137
3347
 
3138
3348
  <code class="ruby"> group_results = @group.result[0 .. MaxGroupResults-1]</code>
3139
3349
  </li>
3140
3350
 
3141
- <li class="covered" data-hits="290" data-linenumber="10">
3142
- <span class="hits">290</span>
3351
+ <li class="covered" data-hits="319" data-linenumber="10">
3352
+ <span class="hits">319</span>
3143
3353
 
3144
3354
  <code class="ruby"> results = []</code>
3145
3355
  </li>
3146
3356
 
3147
- <li class="covered" data-hits="290" data-linenumber="11">
3148
- <span class="hits">290</span>
3357
+ <li class="covered" data-hits="319" data-linenumber="11">
3358
+ <span class="hits">319</span>
3149
3359
 
3150
3360
  <code class="ruby"> min_repeats.upto(max_repeats) do |repeats|</code>
3151
3361
  </li>
3152
3362
 
3153
- <li class="covered" data-hits="320" data-linenumber="12">
3154
- <span class="hits">320</span>
3363
+ <li class="covered" data-hits="349" data-linenumber="12">
3364
+ <span class="hits">349</span>
3155
3365
 
3156
3366
  <code class="ruby"> group_results.each do |group_result|</code>
3157
3367
  </li>
3158
3368
 
3159
- <li class="covered" data-hits="434" data-linenumber="13">
3160
- <span class="hits">434</span>
3369
+ <li class="covered" data-hits="463" data-linenumber="13">
3370
+ <span class="hits">463</span>
3161
3371
 
3162
3372
  <code class="ruby"> results &lt;&lt; group_result * repeats</code>
3163
3373
  </li>
@@ -3174,8 +3384,8 @@
3174
3384
  <code class="ruby"> end</code>
3175
3385
  </li>
3176
3386
 
3177
- <li class="covered" data-hits="290" data-linenumber="16">
3178
- <span class="hits">290</span>
3387
+ <li class="covered" data-hits="319" data-linenumber="16">
3388
+ <span class="hits">319</span>
3179
3389
 
3180
3390
  <code class="ruby"> results.uniq</code>
3181
3391
  </li>
@@ -3210,8 +3420,8 @@
3210
3420
  <code class="ruby"> def initialize(group)</code>
3211
3421
  </li>
3212
3422
 
3213
- <li class="covered" data-hits="265" data-linenumber="22">
3214
- <span class="hits">265</span>
3423
+ <li class="covered" data-hits="335" data-linenumber="22">
3424
+ <span class="hits">335</span>
3215
3425
 
3216
3426
  <code class="ruby"> super</code>
3217
3427
  </li>
@@ -3234,8 +3444,8 @@
3234
3444
  <code class="ruby"> def result</code>
3235
3445
  </li>
3236
3446
 
3237
- <li class="covered" data-hits="265" data-linenumber="26">
3238
- <span class="hits">265</span>
3447
+ <li class="covered" data-hits="294" data-linenumber="26">
3448
+ <span class="hits">294</span>
3239
3449
 
3240
3450
  <code class="ruby"> super(1, 1)</code>
3241
3451
  </li>
@@ -3561,8 +3771,8 @@
3561
3771
  <h3>spec/regexp-examples_spec.rb</h3>
3562
3772
  <h4><span class="green">100.0 %</span> covered</h4>
3563
3773
  <div>
3564
- <b>34</b> relevant lines.
3565
- <span class="green"><b>34</b> lines covered</span> and
3774
+ <b>42</b> relevant lines.
3775
+ <span class="green"><b>42</b> lines covered</span> and
3566
3776
  <span class="red"><b>0</b> lines missed.</span>
3567
3777
  </div>
3568
3778
  </div>
@@ -3582,32 +3792,32 @@
3582
3792
  <code class="ruby"> def self.examples_exist_and_match(*regexps)</code>
3583
3793
  </li>
3584
3794
 
3585
- <li class="covered" data-hits="10" data-linenumber="3">
3586
- <span class="hits">10</span>
3795
+ <li class="covered" data-hits="11" data-linenumber="3">
3796
+ <span class="hits">11</span>
3587
3797
 
3588
3798
  <code class="ruby"> regexps.each do |regexp|</code>
3589
3799
  </li>
3590
3800
 
3591
- <li class="covered" data-hits="69" data-linenumber="4">
3592
- <span class="hits">69</span>
3801
+ <li class="covered" data-hits="75" data-linenumber="4">
3802
+ <span class="hits">75</span>
3593
3803
 
3594
3804
  <code class="ruby"> it do</code>
3595
3805
  </li>
3596
3806
 
3597
- <li class="covered" data-hits="69" data-linenumber="5">
3598
- <span class="hits">69</span>
3807
+ <li class="covered" data-hits="75" data-linenumber="5">
3808
+ <span class="hits">75</span>
3599
3809
 
3600
3810
  <code class="ruby"> regexp_examples = regexp.examples</code>
3601
3811
  </li>
3602
3812
 
3603
- <li class="covered" data-hits="69" data-linenumber="6">
3604
- <span class="hits">69</span>
3813
+ <li class="covered" data-hits="75" data-linenumber="6">
3814
+ <span class="hits">75</span>
3605
3815
 
3606
3816
  <code class="ruby"> expect(regexp_examples).not_to be_empty</code>
3607
3817
  </li>
3608
3818
 
3609
- <li class="covered" data-hits="234" data-linenumber="7">
3610
- <span class="hits">234</span>
3819
+ <li class="covered" data-hits="246" data-linenumber="7">
3820
+ <span class="hits">246</span>
3611
3821
 
3612
3822
  <code class="ruby"> regexp_examples.each { |example| expect(example).to match(/\A(?:#{regexp.source})\z/) }</code>
3613
3823
  </li>
@@ -3672,14 +3882,14 @@
3672
3882
  <code class="ruby"> regexps.each do |regexp|</code>
3673
3883
  </li>
3674
3884
 
3675
- <li class="covered" data-hits="4" data-linenumber="18">
3676
- <span class="hits">4</span>
3885
+ <li class="covered" data-hits="12" data-linenumber="18">
3886
+ <span class="hits">12</span>
3677
3887
 
3678
3888
  <code class="ruby"> it do</code>
3679
3889
  </li>
3680
3890
 
3681
- <li class="covered" data-hits="8" data-linenumber="19">
3682
- <span class="hits">8</span>
3891
+ <li class="covered" data-hits="24" data-linenumber="19">
3892
+ <span class="hits">24</span>
3683
3893
 
3684
3894
  <code class="ruby"> expect{regexp.examples}.to raise_error RegexpExamples::IllegalSyntaxError</code>
3685
3895
  </li>
@@ -3711,790 +3921,1012 @@
3711
3921
  <li class="covered" data-hits="1" data-linenumber="24">
3712
3922
  <span class="hits">1</span>
3713
3923
 
3714
- <code class="ruby"> context &#39;returns matching strings&#39; do</code>
3924
+ <code class="ruby"> def self.examples_raise_unsupported_syntax_error(*regexps)</code>
3715
3925
  </li>
3716
3926
 
3717
3927
  <li class="covered" data-hits="1" data-linenumber="25">
3718
3928
  <span class="hits">1</span>
3719
3929
 
3930
+ <code class="ruby"> regexps.each do |regexp|</code>
3931
+ </li>
3932
+
3933
+ <li class="covered" data-hits="5" data-linenumber="26">
3934
+ <span class="hits">5</span>
3935
+
3936
+ <code class="ruby"> it do</code>
3937
+ </li>
3938
+
3939
+ <li class="covered" data-hits="10" data-linenumber="27">
3940
+ <span class="hits">10</span>
3941
+
3942
+ <code class="ruby"> expect{regexp.examples}.to raise_error RegexpExamples::UnsupportedSyntaxError</code>
3943
+ </li>
3944
+
3945
+ <li class="never" data-hits="" data-linenumber="28">
3946
+
3947
+
3948
+ <code class="ruby"> end</code>
3949
+ </li>
3950
+
3951
+ <li class="never" data-hits="" data-linenumber="29">
3952
+
3953
+
3954
+ <code class="ruby"> end</code>
3955
+ </li>
3956
+
3957
+ <li class="never" data-hits="" data-linenumber="30">
3958
+
3959
+
3960
+ <code class="ruby"> end</code>
3961
+ </li>
3962
+
3963
+ <li class="never" data-hits="" data-linenumber="31">
3964
+
3965
+
3966
+ <code class="ruby"></code>
3967
+ </li>
3968
+
3969
+ <li class="covered" data-hits="1" data-linenumber="32">
3970
+ <span class="hits">1</span>
3971
+
3972
+ <code class="ruby"> context &#39;returns matching strings&#39; do</code>
3973
+ </li>
3974
+
3975
+ <li class="covered" data-hits="1" data-linenumber="33">
3976
+ <span class="hits">1</span>
3977
+
3720
3978
  <code class="ruby"> context &quot;for basic repeaters&quot; do</code>
3721
3979
  </li>
3722
3980
 
3723
- <li class="covered" data-hits="1" data-linenumber="26">
3981
+ <li class="covered" data-hits="1" data-linenumber="34">
3724
3982
  <span class="hits">1</span>
3725
3983
 
3726
3984
  <code class="ruby"> examples_exist_and_match(</code>
3727
3985
  </li>
3728
3986
 
3729
- <li class="never" data-hits="" data-linenumber="27">
3987
+ <li class="never" data-hits="" data-linenumber="35">
3730
3988
 
3731
3989
 
3732
3990
  <code class="ruby"> /a/,</code>
3733
3991
  </li>
3734
3992
 
3735
- <li class="never" data-hits="" data-linenumber="28">
3993
+ <li class="never" data-hits="" data-linenumber="36">
3736
3994
 
3737
3995
 
3738
3996
  <code class="ruby"> /a*/,</code>
3739
3997
  </li>
3740
3998
 
3741
- <li class="never" data-hits="" data-linenumber="29">
3999
+ <li class="never" data-hits="" data-linenumber="37">
3742
4000
 
3743
4001
 
3744
4002
  <code class="ruby"> /a+/,</code>
3745
4003
  </li>
3746
4004
 
3747
- <li class="never" data-hits="" data-linenumber="30">
4005
+ <li class="never" data-hits="" data-linenumber="38">
3748
4006
 
3749
4007
 
3750
4008
  <code class="ruby"> /a?/,</code>
3751
4009
  </li>
3752
4010
 
3753
- <li class="never" data-hits="" data-linenumber="31">
4011
+ <li class="never" data-hits="" data-linenumber="39">
3754
4012
 
3755
4013
 
3756
4014
  <code class="ruby"> /a{1}/,</code>
3757
4015
  </li>
3758
4016
 
3759
- <li class="never" data-hits="" data-linenumber="32">
4017
+ <li class="never" data-hits="" data-linenumber="40">
3760
4018
 
3761
4019
 
3762
4020
  <code class="ruby"> /a{1,}/,</code>
3763
4021
  </li>
3764
4022
 
3765
- <li class="never" data-hits="" data-linenumber="33">
4023
+ <li class="never" data-hits="" data-linenumber="41">
3766
4024
 
3767
4025
 
3768
4026
  <code class="ruby"> /a{,2}/,</code>
3769
4027
  </li>
3770
4028
 
3771
- <li class="never" data-hits="" data-linenumber="34">
4029
+ <li class="never" data-hits="" data-linenumber="42">
3772
4030
 
3773
4031
 
3774
4032
  <code class="ruby"> /a{1,2}/</code>
3775
4033
  </li>
3776
4034
 
3777
- <li class="never" data-hits="" data-linenumber="35">
4035
+ <li class="never" data-hits="" data-linenumber="43">
3778
4036
 
3779
4037
 
3780
4038
  <code class="ruby"> )</code>
3781
4039
  </li>
3782
4040
 
3783
- <li class="never" data-hits="" data-linenumber="36">
4041
+ <li class="never" data-hits="" data-linenumber="44">
3784
4042
 
3785
4043
 
3786
4044
  <code class="ruby"> end</code>
3787
4045
  </li>
3788
4046
 
3789
- <li class="never" data-hits="" data-linenumber="37">
4047
+ <li class="never" data-hits="" data-linenumber="45">
3790
4048
 
3791
4049
 
3792
4050
  <code class="ruby"></code>
3793
4051
  </li>
3794
4052
 
3795
- <li class="covered" data-hits="1" data-linenumber="38">
4053
+ <li class="covered" data-hits="1" data-linenumber="46">
3796
4054
  <span class="hits">1</span>
3797
4055
 
3798
4056
  <code class="ruby"> context &quot;for basic groups&quot; do</code>
3799
4057
  </li>
3800
4058
 
3801
- <li class="covered" data-hits="1" data-linenumber="39">
4059
+ <li class="covered" data-hits="1" data-linenumber="47">
3802
4060
  <span class="hits">1</span>
3803
4061
 
3804
4062
  <code class="ruby"> examples_exist_and_match(</code>
3805
4063
  </li>
3806
4064
 
3807
- <li class="never" data-hits="" data-linenumber="40">
4065
+ <li class="never" data-hits="" data-linenumber="48">
3808
4066
 
3809
4067
 
3810
4068
  <code class="ruby"> /[a]/,</code>
3811
4069
  </li>
3812
4070
 
3813
- <li class="never" data-hits="" data-linenumber="41">
4071
+ <li class="never" data-hits="" data-linenumber="49">
3814
4072
 
3815
4073
 
3816
4074
  <code class="ruby"> /(a)/,</code>
3817
4075
  </li>
3818
4076
 
3819
- <li class="never" data-hits="" data-linenumber="42">
4077
+ <li class="never" data-hits="" data-linenumber="50">
3820
4078
 
3821
4079
 
3822
4080
  <code class="ruby"> /a|b/,</code>
3823
4081
  </li>
3824
4082
 
3825
- <li class="never" data-hits="" data-linenumber="43">
4083
+ <li class="never" data-hits="" data-linenumber="51">
3826
4084
 
3827
4085
 
3828
4086
  <code class="ruby"> /./</code>
3829
4087
  </li>
3830
4088
 
3831
- <li class="never" data-hits="" data-linenumber="44">
4089
+ <li class="never" data-hits="" data-linenumber="52">
3832
4090
 
3833
4091
 
3834
4092
  <code class="ruby"> )</code>
3835
4093
  </li>
3836
4094
 
3837
- <li class="never" data-hits="" data-linenumber="45">
4095
+ <li class="never" data-hits="" data-linenumber="53">
3838
4096
 
3839
4097
 
3840
4098
  <code class="ruby"> end</code>
3841
4099
  </li>
3842
4100
 
3843
- <li class="never" data-hits="" data-linenumber="46">
4101
+ <li class="never" data-hits="" data-linenumber="54">
3844
4102
 
3845
4103
 
3846
4104
  <code class="ruby"></code>
3847
4105
  </li>
3848
4106
 
3849
- <li class="covered" data-hits="1" data-linenumber="47">
4107
+ <li class="covered" data-hits="1" data-linenumber="55">
3850
4108
  <span class="hits">1</span>
3851
4109
 
3852
4110
  <code class="ruby"> context &quot;for complex char groups (square brackets)&quot; do</code>
3853
4111
  </li>
3854
4112
 
3855
- <li class="covered" data-hits="1" data-linenumber="48">
4113
+ <li class="covered" data-hits="1" data-linenumber="56">
3856
4114
  <span class="hits">1</span>
3857
4115
 
3858
4116
  <code class="ruby"> examples_exist_and_match(</code>
3859
4117
  </li>
3860
4118
 
3861
- <li class="never" data-hits="" data-linenumber="49">
4119
+ <li class="never" data-hits="" data-linenumber="57">
3862
4120
 
3863
4121
 
3864
4122
  <code class="ruby"> /[abc]/,</code>
3865
4123
  </li>
3866
4124
 
3867
- <li class="never" data-hits="" data-linenumber="50">
4125
+ <li class="never" data-hits="" data-linenumber="58">
3868
4126
 
3869
4127
 
3870
4128
  <code class="ruby"> /[a-c]/,</code>
3871
4129
  </li>
3872
4130
 
3873
- <li class="never" data-hits="" data-linenumber="51">
4131
+ <li class="never" data-hits="" data-linenumber="59">
3874
4132
 
3875
4133
 
3876
4134
  <code class="ruby"> /[abc-e]/,</code>
3877
4135
  </li>
3878
4136
 
3879
- <li class="never" data-hits="" data-linenumber="52">
4137
+ <li class="never" data-hits="" data-linenumber="60">
3880
4138
 
3881
4139
 
3882
4140
  <code class="ruby"> /[^a-zA-Z]/,</code>
3883
4141
  </li>
3884
4142
 
3885
- <li class="never" data-hits="" data-linenumber="53">
4143
+ <li class="never" data-hits="" data-linenumber="61">
3886
4144
 
3887
4145
 
3888
4146
  <code class="ruby"> /[\w]/,</code>
3889
4147
  </li>
3890
4148
 
3891
- <li class="never" data-hits="" data-linenumber="54">
4149
+ <li class="never" data-hits="" data-linenumber="62">
3892
4150
 
3893
4151
 
3894
4152
  <code class="ruby"> /[]]/, # TODO: How to suppress annoying warnings on this test?</code>
3895
4153
  </li>
3896
4154
 
3897
- <li class="never" data-hits="" data-linenumber="55">
4155
+ <li class="never" data-hits="" data-linenumber="63">
3898
4156
 
3899
4157
 
3900
4158
  <code class="ruby"> /[\]]/,</code>
3901
4159
  </li>
3902
4160
 
3903
- <li class="never" data-hits="" data-linenumber="56">
4161
+ <li class="never" data-hits="" data-linenumber="64">
3904
4162
 
3905
4163
 
3906
4164
  <code class="ruby"> /[\\]/,</code>
3907
4165
  </li>
3908
4166
 
3909
- <li class="never" data-hits="" data-linenumber="57">
4167
+ <li class="never" data-hits="" data-linenumber="65">
3910
4168
 
3911
4169
 
3912
4170
  <code class="ruby"> /[\\\]]/,</code>
3913
4171
  </li>
3914
4172
 
3915
- <li class="never" data-hits="" data-linenumber="58">
4173
+ <li class="never" data-hits="" data-linenumber="66">
3916
4174
 
3917
4175
 
3918
4176
  <code class="ruby"> /[\n-\r]/,</code>
3919
4177
  </li>
3920
4178
 
3921
- <li class="never" data-hits="" data-linenumber="59">
4179
+ <li class="never" data-hits="" data-linenumber="67">
3922
4180
 
3923
4181
 
3924
4182
  <code class="ruby"> /[\-]/,</code>
3925
4183
  </li>
3926
4184
 
3927
- <li class="never" data-hits="" data-linenumber="60">
4185
+ <li class="never" data-hits="" data-linenumber="68">
3928
4186
 
3929
4187
 
3930
4188
  <code class="ruby"> /[%-+]/ # This regex is &quot;supposed to&quot; match some surprising things!!!</code>
3931
4189
  </li>
3932
4190
 
3933
- <li class="never" data-hits="" data-linenumber="61">
4191
+ <li class="never" data-hits="" data-linenumber="69">
3934
4192
 
3935
4193
 
3936
4194
  <code class="ruby"> )</code>
3937
4195
  </li>
3938
4196
 
3939
- <li class="never" data-hits="" data-linenumber="62">
4197
+ <li class="never" data-hits="" data-linenumber="70">
3940
4198
 
3941
4199
 
3942
4200
  <code class="ruby"> end</code>
3943
4201
  </li>
3944
4202
 
3945
- <li class="never" data-hits="" data-linenumber="63">
4203
+ <li class="never" data-hits="" data-linenumber="71">
3946
4204
 
3947
4205
 
3948
4206
  <code class="ruby"></code>
3949
4207
  </li>
3950
4208
 
3951
- <li class="covered" data-hits="1" data-linenumber="64">
4209
+ <li class="covered" data-hits="1" data-linenumber="72">
3952
4210
  <span class="hits">1</span>
3953
4211
 
3954
4212
  <code class="ruby"> context &quot;for complex multi groups&quot; do</code>
3955
4213
  </li>
3956
4214
 
3957
- <li class="covered" data-hits="1" data-linenumber="65">
4215
+ <li class="covered" data-hits="1" data-linenumber="73">
3958
4216
  <span class="hits">1</span>
3959
4217
 
3960
4218
  <code class="ruby"> examples_exist_and_match(</code>
3961
4219
  </li>
3962
4220
 
3963
- <li class="never" data-hits="" data-linenumber="66">
4221
+ <li class="never" data-hits="" data-linenumber="74">
3964
4222
 
3965
4223
 
3966
4224
  <code class="ruby"> /(normal)/,</code>
3967
4225
  </li>
3968
4226
 
3969
- <li class="never" data-hits="" data-linenumber="67">
4227
+ <li class="never" data-hits="" data-linenumber="75">
3970
4228
 
3971
4229
 
3972
4230
  <code class="ruby"> /(?:nocapture)/,</code>
3973
4231
  </li>
3974
4232
 
3975
- <li class="never" data-hits="" data-linenumber="68">
4233
+ <li class="never" data-hits="" data-linenumber="76">
3976
4234
 
3977
4235
 
3978
4236
  <code class="ruby"> /(?&lt;name&gt;namedgroup)/,</code>
3979
4237
  </li>
3980
4238
 
3981
- <li class="never" data-hits="" data-linenumber="69">
4239
+ <li class="never" data-hits="" data-linenumber="77">
3982
4240
 
3983
4241
 
3984
4242
  <code class="ruby"> /(?&lt;name&gt;namedgroup) \k&lt;name&gt;/</code>
3985
4243
  </li>
3986
4244
 
3987
- <li class="never" data-hits="" data-linenumber="70">
4245
+ <li class="never" data-hits="" data-linenumber="78">
3988
4246
 
3989
4247
 
3990
4248
  <code class="ruby"> )</code>
3991
4249
  </li>
3992
4250
 
3993
- <li class="never" data-hits="" data-linenumber="71">
4251
+ <li class="never" data-hits="" data-linenumber="79">
3994
4252
 
3995
4253
 
3996
4254
  <code class="ruby"> end</code>
3997
4255
  </li>
3998
4256
 
3999
- <li class="never" data-hits="" data-linenumber="72">
4257
+ <li class="never" data-hits="" data-linenumber="80">
4000
4258
 
4001
4259
 
4002
4260
  <code class="ruby"></code>
4003
4261
  </li>
4004
4262
 
4005
- <li class="covered" data-hits="1" data-linenumber="73">
4263
+ <li class="covered" data-hits="1" data-linenumber="81">
4006
4264
  <span class="hits">1</span>
4007
4265
 
4008
4266
  <code class="ruby"> context &quot;for escaped characters&quot; do</code>
4009
4267
  </li>
4010
4268
 
4011
- <li class="covered" data-hits="1" data-linenumber="74">
4269
+ <li class="covered" data-hits="1" data-linenumber="82">
4012
4270
  <span class="hits">1</span>
4013
4271
 
4014
4272
  <code class="ruby"> examples_exist_and_match(</code>
4015
4273
  </li>
4016
4274
 
4017
- <li class="never" data-hits="" data-linenumber="75">
4275
+ <li class="never" data-hits="" data-linenumber="83">
4018
4276
 
4019
4277
 
4020
4278
  <code class="ruby"> /\w/,</code>
4021
4279
  </li>
4022
4280
 
4023
- <li class="never" data-hits="" data-linenumber="76">
4281
+ <li class="never" data-hits="" data-linenumber="84">
4024
4282
 
4025
4283
 
4026
4284
  <code class="ruby"> /\W/,</code>
4027
4285
  </li>
4028
4286
 
4029
- <li class="never" data-hits="" data-linenumber="77">
4287
+ <li class="never" data-hits="" data-linenumber="85">
4030
4288
 
4031
4289
 
4032
4290
  <code class="ruby"> /\s/,</code>
4033
4291
  </li>
4034
4292
 
4035
- <li class="never" data-hits="" data-linenumber="78">
4293
+ <li class="never" data-hits="" data-linenumber="86">
4036
4294
 
4037
4295
 
4038
4296
  <code class="ruby"> /\S/,</code>
4039
4297
  </li>
4040
4298
 
4041
- <li class="never" data-hits="" data-linenumber="79">
4299
+ <li class="never" data-hits="" data-linenumber="87">
4042
4300
 
4043
4301
 
4044
4302
  <code class="ruby"> /\d/,</code>
4045
4303
  </li>
4046
4304
 
4047
- <li class="never" data-hits="" data-linenumber="80">
4305
+ <li class="never" data-hits="" data-linenumber="88">
4048
4306
 
4049
4307
 
4050
4308
  <code class="ruby"> /\D/,</code>
4051
4309
  </li>
4052
4310
 
4053
- <li class="never" data-hits="" data-linenumber="81">
4311
+ <li class="never" data-hits="" data-linenumber="89">
4054
4312
 
4055
4313
 
4056
4314
  <code class="ruby"> /\h/,</code>
4057
4315
  </li>
4058
4316
 
4059
- <li class="never" data-hits="" data-linenumber="82">
4317
+ <li class="never" data-hits="" data-linenumber="90">
4060
4318
 
4061
4319
 
4062
4320
  <code class="ruby"> /\H/,</code>
4063
4321
  </li>
4064
4322
 
4065
- <li class="never" data-hits="" data-linenumber="83">
4323
+ <li class="never" data-hits="" data-linenumber="91">
4066
4324
 
4067
4325
 
4068
4326
  <code class="ruby"> /\t/,</code>
4069
4327
  </li>
4070
4328
 
4071
- <li class="never" data-hits="" data-linenumber="84">
4329
+ <li class="never" data-hits="" data-linenumber="92">
4072
4330
 
4073
4331
 
4074
4332
  <code class="ruby"> /\n/,</code>
4075
4333
  </li>
4076
4334
 
4077
- <li class="never" data-hits="" data-linenumber="85">
4335
+ <li class="never" data-hits="" data-linenumber="93">
4078
4336
 
4079
4337
 
4080
4338
  <code class="ruby"> /\f/,</code>
4081
4339
  </li>
4082
4340
 
4083
- <li class="never" data-hits="" data-linenumber="86">
4341
+ <li class="never" data-hits="" data-linenumber="94">
4084
4342
 
4085
4343
 
4086
4344
  <code class="ruby"> /\a/,</code>
4087
4345
  </li>
4088
4346
 
4089
- <li class="never" data-hits="" data-linenumber="87">
4347
+ <li class="never" data-hits="" data-linenumber="95">
4090
4348
 
4091
4349
 
4092
4350
  <code class="ruby"> /\v/,</code>
4093
4351
  </li>
4094
4352
 
4095
- <li class="never" data-hits="" data-linenumber="88">
4353
+ <li class="never" data-hits="" data-linenumber="96">
4096
4354
 
4097
4355
 
4098
4356
  <code class="ruby"> /\e/</code>
4099
4357
  </li>
4100
4358
 
4101
- <li class="never" data-hits="" data-linenumber="89">
4359
+ <li class="never" data-hits="" data-linenumber="97">
4102
4360
 
4103
4361
 
4104
4362
  <code class="ruby"> )</code>
4105
4363
  </li>
4106
4364
 
4107
- <li class="never" data-hits="" data-linenumber="90">
4365
+ <li class="never" data-hits="" data-linenumber="98">
4108
4366
 
4109
4367
 
4110
4368
  <code class="ruby"> end</code>
4111
4369
  </li>
4112
4370
 
4113
- <li class="never" data-hits="" data-linenumber="91">
4371
+ <li class="never" data-hits="" data-linenumber="99">
4114
4372
 
4115
4373
 
4116
4374
  <code class="ruby"></code>
4117
4375
  </li>
4118
4376
 
4119
- <li class="covered" data-hits="1" data-linenumber="92">
4377
+ <li class="covered" data-hits="1" data-linenumber="100">
4120
4378
  <span class="hits">1</span>
4121
4379
 
4122
4380
  <code class="ruby"> context &quot;for backreferences&quot; do</code>
4123
4381
  </li>
4124
4382
 
4125
- <li class="covered" data-hits="1" data-linenumber="93">
4383
+ <li class="covered" data-hits="1" data-linenumber="101">
4126
4384
  <span class="hits">1</span>
4127
4385
 
4128
4386
  <code class="ruby"> examples_exist_and_match(</code>
4129
4387
  </li>
4130
4388
 
4131
- <li class="never" data-hits="" data-linenumber="94">
4389
+ <li class="never" data-hits="" data-linenumber="102">
4132
4390
 
4133
4391
 
4134
4392
  <code class="ruby"> /(repeat) \1/,</code>
4135
4393
  </li>
4136
4394
 
4137
- <li class="never" data-hits="" data-linenumber="95">
4395
+ <li class="never" data-hits="" data-linenumber="103">
4138
4396
 
4139
4397
 
4140
4398
  <code class="ruby"> /(ref1) (ref2) \1 \2/,</code>
4141
4399
  </li>
4142
4400
 
4143
- <li class="never" data-hits="" data-linenumber="96">
4401
+ <li class="never" data-hits="" data-linenumber="104">
4144
4402
 
4145
4403
 
4146
4404
  <code class="ruby"> /((ref2)ref1) \1 \2/,</code>
4147
4405
  </li>
4148
4406
 
4149
- <li class="never" data-hits="" data-linenumber="97">
4407
+ <li class="never" data-hits="" data-linenumber="105">
4150
4408
 
4151
4409
 
4152
4410
  <code class="ruby"> /((ref1and2)) \1 \2/,</code>
4153
4411
  </li>
4154
4412
 
4155
- <li class="never" data-hits="" data-linenumber="98">
4413
+ <li class="never" data-hits="" data-linenumber="106">
4156
4414
 
4157
4415
 
4158
4416
  <code class="ruby"> /(one)(two)(three)(four)(five)(six)(seven)(eight)(nine)(ten) \10\9\8\7\6\5\4\3\2\1/,</code>
4159
4417
  </li>
4160
4418
 
4161
- <li class="never" data-hits="" data-linenumber="99">
4419
+ <li class="never" data-hits="" data-linenumber="107">
4162
4420
 
4163
4421
 
4164
4422
  <code class="ruby"> /(a?(b?(c?(d?(e?)))))/</code>
4165
4423
  </li>
4166
4424
 
4167
- <li class="never" data-hits="" data-linenumber="100">
4425
+ <li class="never" data-hits="" data-linenumber="108">
4168
4426
 
4169
4427
 
4170
4428
  <code class="ruby"> )</code>
4171
4429
  </li>
4172
4430
 
4173
- <li class="never" data-hits="" data-linenumber="101">
4431
+ <li class="never" data-hits="" data-linenumber="109">
4174
4432
 
4175
4433
 
4176
4434
  <code class="ruby"> end</code>
4177
4435
  </li>
4178
4436
 
4179
- <li class="never" data-hits="" data-linenumber="102">
4437
+ <li class="never" data-hits="" data-linenumber="110">
4180
4438
 
4181
4439
 
4182
4440
  <code class="ruby"></code>
4183
4441
  </li>
4184
4442
 
4185
- <li class="covered" data-hits="1" data-linenumber="103">
4443
+ <li class="covered" data-hits="1" data-linenumber="111">
4186
4444
  <span class="hits">1</span>
4187
4445
 
4188
4446
  <code class="ruby"> context &quot;for complex patterns&quot; do</code>
4189
4447
  </li>
4190
4448
 
4191
- <li class="never" data-hits="" data-linenumber="104">
4449
+ <li class="never" data-hits="" data-linenumber="112">
4192
4450
 
4193
4451
 
4194
4452
  <code class="ruby"> # Longer combinations of the above</code>
4195
4453
  </li>
4196
4454
 
4197
- <li class="covered" data-hits="1" data-linenumber="105">
4455
+ <li class="covered" data-hits="1" data-linenumber="113">
4198
4456
  <span class="hits">1</span>
4199
4457
 
4200
4458
  <code class="ruby"> examples_exist_and_match(</code>
4201
4459
  </li>
4202
4460
 
4203
- <li class="never" data-hits="" data-linenumber="106">
4461
+ <li class="never" data-hits="" data-linenumber="114">
4204
4462
 
4205
4463
 
4206
4464
  <code class="ruby"> /https?:\/\/(www\.)github\.com/,</code>
4207
4465
  </li>
4208
4466
 
4209
- <li class="never" data-hits="" data-linenumber="107">
4467
+ <li class="never" data-hits="" data-linenumber="115">
4210
4468
 
4211
4469
 
4212
4470
  <code class="ruby"> /(I(N(C(E(P(T(I(O(N)))))))))*/,</code>
4213
4471
  </li>
4214
4472
 
4215
- <li class="never" data-hits="" data-linenumber="108">
4473
+ <li class="never" data-hits="" data-linenumber="116">
4216
4474
 
4217
4475
 
4218
4476
  <code class="ruby"> /[\w]{1}/,</code>
4219
4477
  </li>
4220
4478
 
4221
- <li class="never" data-hits="" data-linenumber="109">
4479
+ <li class="never" data-hits="" data-linenumber="117">
4222
4480
 
4223
4481
 
4224
4482
  <code class="ruby"> /((a?b*c+)) \1/,</code>
4225
4483
  </li>
4226
4484
 
4227
- <li class="never" data-hits="" data-linenumber="110">
4485
+ <li class="never" data-hits="" data-linenumber="118">
4228
4486
 
4229
4487
 
4230
4488
  <code class="ruby"> /((a?b*c+)?) \1/,</code>
4231
4489
  </li>
4232
4490
 
4233
- <li class="never" data-hits="" data-linenumber="111">
4491
+ <li class="never" data-hits="" data-linenumber="119">
4234
4492
 
4235
4493
 
4236
4494
  <code class="ruby"> /a|b|c|d/,</code>
4237
4495
  </li>
4238
4496
 
4239
- <li class="never" data-hits="" data-linenumber="112">
4497
+ <li class="never" data-hits="" data-linenumber="120">
4240
4498
 
4241
4499
 
4242
4500
  <code class="ruby"> /a+|b*|c?/</code>
4243
4501
  </li>
4244
4502
 
4245
- <li class="never" data-hits="" data-linenumber="113">
4503
+ <li class="never" data-hits="" data-linenumber="121">
4246
4504
 
4247
4505
 
4248
4506
  <code class="ruby"> )</code>
4249
4507
  </li>
4250
4508
 
4251
- <li class="never" data-hits="" data-linenumber="114">
4509
+ <li class="never" data-hits="" data-linenumber="122">
4252
4510
 
4253
4511
 
4254
4512
  <code class="ruby"> end</code>
4255
4513
  </li>
4256
4514
 
4257
- <li class="never" data-hits="" data-linenumber="115">
4515
+ <li class="never" data-hits="" data-linenumber="123">
4258
4516
 
4259
4517
 
4260
4518
  <code class="ruby"></code>
4261
4519
  </li>
4262
4520
 
4263
- <li class="covered" data-hits="1" data-linenumber="116">
4521
+ <li class="covered" data-hits="1" data-linenumber="124">
4264
4522
  <span class="hits">1</span>
4265
4523
 
4266
4524
  <code class="ruby"> context &quot;for illegal syntax&quot; do</code>
4267
4525
  </li>
4268
4526
 
4269
- <li class="covered" data-hits="1" data-linenumber="117">
4527
+ <li class="covered" data-hits="1" data-linenumber="125">
4270
4528
  <span class="hits">1</span>
4271
4529
 
4272
4530
  <code class="ruby"> examples_raise_illegal_syntax_error(</code>
4273
4531
  </li>
4274
4532
 
4275
- <li class="never" data-hits="" data-linenumber="118">
4533
+ <li class="never" data-hits="" data-linenumber="126">
4276
4534
 
4277
4535
 
4278
4536
  <code class="ruby"> /(?=lookahead)/,</code>
4279
4537
  </li>
4280
4538
 
4281
- <li class="never" data-hits="" data-linenumber="119">
4539
+ <li class="never" data-hits="" data-linenumber="127">
4282
4540
 
4283
4541
 
4284
4542
  <code class="ruby"> /(?!neglookahead)/,</code>
4285
4543
  </li>
4286
4544
 
4287
- <li class="never" data-hits="" data-linenumber="120">
4545
+ <li class="never" data-hits="" data-linenumber="128">
4288
4546
 
4289
4547
 
4290
4548
  <code class="ruby"> /(?&lt;=lookbehind)/,</code>
4291
4549
  </li>
4292
4550
 
4293
- <li class="never" data-hits="" data-linenumber="121">
4551
+ <li class="never" data-hits="" data-linenumber="129">
4294
4552
 
4295
4553
 
4296
- <code class="ruby"> /(?&lt;!neglookbehind)/</code>
4554
+ <code class="ruby"> /(?&lt;!neglookbehind)/,</code>
4297
4555
  </li>
4298
4556
 
4299
- <li class="never" data-hits="" data-linenumber="122">
4557
+ <li class="never" data-hits="" data-linenumber="130">
4558
+
4559
+
4560
+ <code class="ruby"> /\bword-boundary/,</code>
4561
+ </li>
4562
+
4563
+ <li class="never" data-hits="" data-linenumber="131">
4564
+
4565
+
4566
+ <code class="ruby"> /no\Bn-word-boundary/,</code>
4567
+ </li>
4568
+
4569
+ <li class="never" data-hits="" data-linenumber="132">
4570
+
4571
+
4572
+ <code class="ruby"> /\Glast-match/,</code>
4573
+ </li>
4574
+
4575
+ <li class="never" data-hits="" data-linenumber="133">
4576
+
4577
+
4578
+ <code class="ruby"> /start-of\A-string/,</code>
4579
+ </li>
4580
+
4581
+ <li class="never" data-hits="" data-linenumber="134">
4582
+
4583
+
4584
+ <code class="ruby"> /start-of^-line/,</code>
4585
+ </li>
4586
+
4587
+ <li class="never" data-hits="" data-linenumber="135">
4588
+
4589
+
4590
+ <code class="ruby"> /end-of\Z-string/,</code>
4591
+ </li>
4592
+
4593
+ <li class="never" data-hits="" data-linenumber="136">
4594
+
4595
+
4596
+ <code class="ruby"> /end-of\z-string/,</code>
4597
+ </li>
4598
+
4599
+ <li class="never" data-hits="" data-linenumber="137">
4600
+
4601
+
4602
+ <code class="ruby"> /end-of$-line/</code>
4603
+ </li>
4604
+
4605
+ <li class="never" data-hits="" data-linenumber="138">
4300
4606
 
4301
4607
 
4302
4608
  <code class="ruby"> )</code>
4303
4609
  </li>
4304
4610
 
4305
- <li class="never" data-hits="" data-linenumber="123">
4611
+ <li class="never" data-hits="" data-linenumber="139">
4306
4612
 
4307
4613
 
4308
4614
  <code class="ruby"> end</code>
4309
4615
  </li>
4310
4616
 
4311
- <li class="never" data-hits="" data-linenumber="124">
4617
+ <li class="never" data-hits="" data-linenumber="140">
4312
4618
 
4313
4619
 
4314
4620
  <code class="ruby"></code>
4315
4621
  </li>
4316
4622
 
4317
- <li class="covered" data-hits="1" data-linenumber="125">
4623
+ <li class="covered" data-hits="1" data-linenumber="141">
4624
+ <span class="hits">1</span>
4625
+
4626
+ <code class="ruby"> context &quot;ignore start/end anchors if at start/end&quot; do</code>
4627
+ </li>
4628
+
4629
+ <li class="covered" data-hits="1" data-linenumber="142">
4630
+ <span class="hits">1</span>
4631
+
4632
+ <code class="ruby"> examples_exist_and_match(</code>
4633
+ </li>
4634
+
4635
+ <li class="never" data-hits="" data-linenumber="143">
4636
+
4637
+
4638
+ <code class="ruby"> /\Astart/,</code>
4639
+ </li>
4640
+
4641
+ <li class="never" data-hits="" data-linenumber="144">
4642
+
4643
+
4644
+ <code class="ruby"> /^start/,</code>
4645
+ </li>
4646
+
4647
+ <li class="never" data-hits="" data-linenumber="145">
4648
+
4649
+
4650
+ <code class="ruby"> /end$/,</code>
4651
+ </li>
4652
+
4653
+ <li class="never" data-hits="" data-linenumber="146">
4654
+
4655
+
4656
+ <code class="ruby"> /end\z/,</code>
4657
+ </li>
4658
+
4659
+ <li class="never" data-hits="" data-linenumber="147">
4660
+
4661
+
4662
+ <code class="ruby"> /end\Z/</code>
4663
+ </li>
4664
+
4665
+ <li class="never" data-hits="" data-linenumber="148">
4666
+
4667
+
4668
+ <code class="ruby"> )</code>
4669
+ </li>
4670
+
4671
+ <li class="never" data-hits="" data-linenumber="149">
4672
+
4673
+
4674
+ <code class="ruby"> end</code>
4675
+ </li>
4676
+
4677
+ <li class="never" data-hits="" data-linenumber="150">
4678
+
4679
+
4680
+ <code class="ruby"></code>
4681
+ </li>
4682
+
4683
+ <li class="covered" data-hits="1" data-linenumber="151">
4684
+ <span class="hits">1</span>
4685
+
4686
+ <code class="ruby"> context &quot;for unsupported syntax&quot; do</code>
4687
+ </li>
4688
+
4689
+ <li class="covered" data-hits="1" data-linenumber="152">
4690
+ <span class="hits">1</span>
4691
+
4692
+ <code class="ruby"> examples_raise_unsupported_syntax_error(</code>
4693
+ </li>
4694
+
4695
+ <li class="never" data-hits="" data-linenumber="153">
4696
+
4697
+
4698
+ <code class="ruby"> /\p{L}/,</code>
4699
+ </li>
4700
+
4701
+ <li class="never" data-hits="" data-linenumber="154">
4702
+
4703
+
4704
+ <code class="ruby"> /\p{Arabic}/,</code>
4705
+ </li>
4706
+
4707
+ <li class="never" data-hits="" data-linenumber="155">
4708
+
4709
+
4710
+ <code class="ruby"> /\p{^Ll}/,</code>
4711
+ </li>
4712
+
4713
+ <li class="never" data-hits="" data-linenumber="156">
4714
+
4715
+
4716
+ <code class="ruby"> /(?&lt;name&gt; ... \g&lt;name&gt;*)/,</code>
4717
+ </li>
4718
+
4719
+ <li class="never" data-hits="" data-linenumber="157">
4720
+
4721
+
4722
+ <code class="ruby"> /[[:space:]]/</code>
4723
+ </li>
4724
+
4725
+ <li class="never" data-hits="" data-linenumber="158">
4726
+
4727
+
4728
+ <code class="ruby"> )</code>
4729
+ </li>
4730
+
4731
+ <li class="never" data-hits="" data-linenumber="159">
4732
+
4733
+
4734
+ <code class="ruby"> end</code>
4735
+ </li>
4736
+
4737
+ <li class="never" data-hits="" data-linenumber="160">
4738
+
4739
+
4740
+ <code class="ruby"></code>
4741
+ </li>
4742
+
4743
+ <li class="covered" data-hits="1" data-linenumber="161">
4318
4744
  <span class="hits">1</span>
4319
4745
 
4320
4746
  <code class="ruby"> context &quot;for control characters&quot; do</code>
4321
4747
  </li>
4322
4748
 
4323
- <li class="covered" data-hits="1" data-linenumber="126">
4749
+ <li class="covered" data-hits="1" data-linenumber="162">
4324
4750
  <span class="hits">1</span>
4325
4751
 
4326
4752
  <code class="ruby"> examples_exist_and_match(</code>
4327
4753
  </li>
4328
4754
 
4329
- <li class="never" data-hits="" data-linenumber="127">
4755
+ <li class="never" data-hits="" data-linenumber="163">
4330
4756
 
4331
4757
 
4332
4758
  <code class="ruby"> /\ca/,</code>
4333
4759
  </li>
4334
4760
 
4335
- <li class="never" data-hits="" data-linenumber="128">
4761
+ <li class="never" data-hits="" data-linenumber="164">
4336
4762
 
4337
4763
 
4338
4764
  <code class="ruby"> /\cZ/,</code>
4339
4765
  </li>
4340
4766
 
4341
- <li class="never" data-hits="" data-linenumber="129">
4767
+ <li class="never" data-hits="" data-linenumber="165">
4342
4768
 
4343
4769
 
4344
4770
  <code class="ruby"> /\c9/,</code>
4345
4771
  </li>
4346
4772
 
4347
- <li class="never" data-hits="" data-linenumber="130">
4773
+ <li class="never" data-hits="" data-linenumber="166">
4348
4774
 
4349
4775
 
4350
4776
  <code class="ruby"> /\c[/,</code>
4351
4777
  </li>
4352
4778
 
4353
- <li class="never" data-hits="" data-linenumber="131">
4779
+ <li class="never" data-hits="" data-linenumber="167">
4354
4780
 
4355
4781
 
4356
4782
  <code class="ruby"> /\c#/,</code>
4357
4783
  </li>
4358
4784
 
4359
- <li class="never" data-hits="" data-linenumber="132">
4785
+ <li class="never" data-hits="" data-linenumber="168">
4360
4786
 
4361
4787
 
4362
4788
  <code class="ruby"> /\c?/,</code>
4363
4789
  </li>
4364
4790
 
4365
- <li class="never" data-hits="" data-linenumber="133">
4791
+ <li class="never" data-hits="" data-linenumber="169">
4366
4792
 
4367
4793
 
4368
4794
  <code class="ruby"> /\C-a/,</code>
4369
4795
  </li>
4370
4796
 
4371
- <li class="never" data-hits="" data-linenumber="134">
4797
+ <li class="never" data-hits="" data-linenumber="170">
4372
4798
 
4373
4799
 
4374
4800
  <code class="ruby"> /\C-&amp;/</code>
4375
4801
  </li>
4376
4802
 
4377
- <li class="never" data-hits="" data-linenumber="135">
4803
+ <li class="never" data-hits="" data-linenumber="171">
4378
4804
 
4379
4805
 
4380
4806
  <code class="ruby"> )</code>
4381
4807
  </li>
4382
4808
 
4383
- <li class="never" data-hits="" data-linenumber="136">
4809
+ <li class="never" data-hits="" data-linenumber="172">
4384
4810
 
4385
4811
 
4386
4812
  <code class="ruby"> end</code>
4387
4813
  </li>
4388
4814
 
4389
- <li class="never" data-hits="" data-linenumber="137">
4815
+ <li class="never" data-hits="" data-linenumber="173">
4390
4816
 
4391
4817
 
4392
4818
  <code class="ruby"></code>
4393
4819
  </li>
4394
4820
 
4395
- <li class="covered" data-hits="1" data-linenumber="138">
4821
+ <li class="covered" data-hits="1" data-linenumber="174">
4396
4822
  <span class="hits">1</span>
4397
4823
 
4398
4824
  <code class="ruby"> context &quot;for escape sequences&quot; do</code>
4399
4825
  </li>
4400
4826
 
4401
- <li class="covered" data-hits="1" data-linenumber="139">
4827
+ <li class="covered" data-hits="1" data-linenumber="175">
4402
4828
  <span class="hits">1</span>
4403
4829
 
4404
4830
  <code class="ruby"> examples_exist_and_match(</code>
4405
4831
  </li>
4406
4832
 
4407
- <li class="never" data-hits="" data-linenumber="140">
4833
+ <li class="never" data-hits="" data-linenumber="176">
4408
4834
 
4409
4835
 
4410
4836
  <code class="ruby"> /\x42/,</code>
4411
4837
  </li>
4412
4838
 
4413
- <li class="never" data-hits="" data-linenumber="141">
4839
+ <li class="never" data-hits="" data-linenumber="177">
4414
4840
 
4415
4841
 
4416
4842
  <code class="ruby"> /\x1D/,</code>
4417
4843
  </li>
4418
4844
 
4419
- <li class="never" data-hits="" data-linenumber="142">
4845
+ <li class="never" data-hits="" data-linenumber="178">
4420
4846
 
4421
4847
 
4422
4848
  <code class="ruby"> /\x3word/,</code>
4423
4849
  </li>
4424
4850
 
4425
- <li class="never" data-hits="" data-linenumber="143">
4851
+ <li class="never" data-hits="" data-linenumber="179">
4426
4852
 
4427
4853
 
4428
4854
  <code class="ruby"> /#{&quot;\x80&quot;.force_encoding(&quot;ASCII-8BIT&quot;)}/</code>
4429
4855
  </li>
4430
4856
 
4431
- <li class="never" data-hits="" data-linenumber="144">
4857
+ <li class="never" data-hits="" data-linenumber="180">
4432
4858
 
4433
4859
 
4434
4860
  <code class="ruby"> )</code>
4435
4861
  </li>
4436
4862
 
4437
- <li class="never" data-hits="" data-linenumber="145">
4863
+ <li class="never" data-hits="" data-linenumber="181">
4438
4864
 
4439
4865
 
4440
4866
  <code class="ruby"> end</code>
4441
4867
  </li>
4442
4868
 
4443
- <li class="never" data-hits="" data-linenumber="146">
4869
+ <li class="never" data-hits="" data-linenumber="182">
4444
4870
 
4445
4871
 
4446
4872
  <code class="ruby"></code>
4447
4873
  </li>
4448
4874
 
4449
- <li class="covered" data-hits="1" data-linenumber="147">
4875
+ <li class="covered" data-hits="1" data-linenumber="183">
4450
4876
  <span class="hits">1</span>
4451
4877
 
4452
4878
  <code class="ruby"> context &quot;for unicode sequences&quot; do</code>
4453
4879
  </li>
4454
4880
 
4455
- <li class="covered" data-hits="1" data-linenumber="148">
4881
+ <li class="covered" data-hits="1" data-linenumber="184">
4456
4882
  <span class="hits">1</span>
4457
4883
 
4458
4884
  <code class="ruby"> examples_exist_and_match(</code>
4459
4885
  </li>
4460
4886
 
4461
- <li class="never" data-hits="" data-linenumber="149">
4887
+ <li class="never" data-hits="" data-linenumber="185">
4462
4888
 
4463
4889
 
4464
4890
  <code class="ruby"> /\u6829/,</code>
4465
4891
  </li>
4466
4892
 
4467
- <li class="never" data-hits="" data-linenumber="150">
4893
+ <li class="never" data-hits="" data-linenumber="186">
4468
4894
 
4469
4895
 
4470
- <code class="ruby"> /\uabcd/</code>
4896
+ <code class="ruby"> /\uabcd/,</code>
4471
4897
  </li>
4472
4898
 
4473
- <li class="never" data-hits="" data-linenumber="151">
4899
+ <li class="never" data-hits="" data-linenumber="187">
4900
+
4901
+
4902
+ <code class="ruby"> /\u{42}word/</code>
4903
+ </li>
4904
+
4905
+ <li class="never" data-hits="" data-linenumber="188">
4474
4906
 
4475
4907
 
4476
4908
  <code class="ruby"> )</code>
4477
4909
  </li>
4478
4910
 
4479
- <li class="never" data-hits="" data-linenumber="152">
4911
+ <li class="never" data-hits="" data-linenumber="189">
4480
4912
 
4481
4913
 
4482
4914
  <code class="ruby"> end</code>
4483
4915
  </li>
4484
4916
 
4485
- <li class="never" data-hits="" data-linenumber="153">
4917
+ <li class="never" data-hits="" data-linenumber="190">
4486
4918
 
4487
4919
 
4488
4920
  <code class="ruby"></code>
4489
4921
  </li>
4490
4922
 
4491
- <li class="never" data-hits="" data-linenumber="154">
4923
+ <li class="never" data-hits="" data-linenumber="191">
4492
4924
 
4493
4925
 
4494
4926
  <code class="ruby"> end</code>
4495
4927
  </li>
4496
4928
 
4497
- <li class="never" data-hits="" data-linenumber="155">
4929
+ <li class="never" data-hits="" data-linenumber="192">
4498
4930
 
4499
4931
 
4500
4932
  <code class="ruby">end</code>