regexp-examples 0.2.4 → 0.3.0

Sign up to get free protection for your applications and to get access to all the features.
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>