Update github links.

Author: BurntSushi

CHANGELOG.md

@@ -1,6 +1,6 @@
 0.1.80
 ======
-* [PR #292](https://github.com/rust-lang-nursery/regex/pull/292):
+* [PR #292](https://github.com/rust-lang/regex/pull/292):
   Fixes bug #291, which was introduced by PR #290.
 
 0.1.79
@@ -9,13 +9,13 @@
 
 0.1.78
 ======
-* [PR #290](https://github.com/rust-lang-nursery/regex/pull/290):
+* [PR #290](https://github.com/rust-lang/regex/pull/290):
   Fixes bug #289, which caused some regexes with a certain combination
   of literals to match incorrectly.
 
 0.1.77
 ======
-* [PR #281](https://github.com/rust-lang-nursery/regex/pull/281):
+* [PR #281](https://github.com/rust-lang/regex/pull/281):
   Fixes bug #280 by disabling all literal optimizations when a pattern
   is partially anchored.
 
@@ -25,9 +25,9 @@
 
 0.1.75
 ======
-* [PR #275](https://github.com/rust-lang-nursery/regex/pull/275):
+* [PR #275](https://github.com/rust-lang/regex/pull/275):
   Improves match verification performance in the Teddy SIMD searcher.
-* [PR #278](https://github.com/rust-lang-nursery/regex/pull/278):
+* [PR #278](https://github.com/rust-lang/regex/pull/278):
   Replaces slow substring loop in the Teddy SIMD searcher with Aho-Corasick.
 * Implemented DoubleEndedIterator on regex set match iterators.
 
@@ -36,7 +36,7 @@
 * Release regex-syntax 0.3.5 with a minor bug fix.
 * Fix bug #272.
 * Fix bug #277.
-* [PR #270](https://github.com/rust-lang-nursery/regex/pull/270):
+* [PR #270](https://github.com/rust-lang/regex/pull/270):
   Fixes bugs #264, #268 and an unreported where the DFA cache size could be
   drastically under estimated in some cases (leading to high unexpected memory
   usage).
@@ -48,55 +48,55 @@
 
 0.1.72
 ======
-* [PR #262](https://github.com/rust-lang-nursery/regex/pull/262):
+* [PR #262](https://github.com/rust-lang/regex/pull/262):
   Fixes a number of small bugs caught by fuzz testing (AFL).
 
 0.1.71
 ======
-* [PR #236](https://github.com/rust-lang-nursery/regex/pull/236):
+* [PR #236](https://github.com/rust-lang/regex/pull/236):
   Fix a bug in how suffix literals were extracted, which could lead
   to invalid match behavior in some cases.
 
 0.1.70
 ======
-* [PR #231](https://github.com/rust-lang-nursery/regex/pull/231):
+* [PR #231](https://github.com/rust-lang/regex/pull/231):
   Add SIMD accelerated multiple pattern search.
-* [PR #228](https://github.com/rust-lang-nursery/regex/pull/228):
+* [PR #228](https://github.com/rust-lang/regex/pull/228):
   Reintroduce the reverse suffix literal optimization.
-* [PR #226](https://github.com/rust-lang-nursery/regex/pull/226):
+* [PR #226](https://github.com/rust-lang/regex/pull/226):
   Implements NFA state compression in the lazy DFA.
-* [PR #223](https://github.com/rust-lang-nursery/regex/pull/223):
+* [PR #223](https://github.com/rust-lang/regex/pull/223):
   A fully anchored RegexSet can now short-circuit.
 
 0.1.69
 ======
-* [PR #216](https://github.com/rust-lang-nursery/regex/pull/216):
+* [PR #216](https://github.com/rust-lang/regex/pull/216):
   Tweak the threshold for running backtracking.
-* [PR #217](https://github.com/rust-lang-nursery/regex/pull/217):
+* [PR #217](https://github.com/rust-lang/regex/pull/217):
   Add upper limit (from the DFA) to capture search (for the NFA).
-* [PR #218](https://github.com/rust-lang-nursery/regex/pull/218):
+* [PR #218](https://github.com/rust-lang/regex/pull/218):
   Add rure, a C API.
 
 0.1.68
 ======
-* [PR #210](https://github.com/rust-lang-nursery/regex/pull/210):
+* [PR #210](https://github.com/rust-lang/regex/pull/210):
   Fixed a performance bug in `bytes::Regex::replace` where `extend` was used
   instead of `extend_from_slice`.
-* [PR #211](https://github.com/rust-lang-nursery/regex/pull/211):
+* [PR #211](https://github.com/rust-lang/regex/pull/211):
   Fixed a bug in the handling of word boundaries in the DFA.
-* [PR #213](https://github.com/rust-lang-nursery/regex/pull/213):
+* [PR #213](https://github.com/rust-lang/pull/213):
   Added RE2 and Tcl to the benchmark harness. Also added a CLI utility from
   running regexes using any of the following regex engines: PCRE1, PCRE2,
   Oniguruma, RE2, Tcl and of course Rust's own regexes.
 
 0.1.67
 ======
-* [PR #201](https://github.com/rust-lang-nursery/regex/pull/201):
+* [PR #201](https://github.com/rust-lang/regex/pull/201):
   Fix undefined behavior in the `regex!` compiler plugin macro.
-* [PR #205](https://github.com/rust-lang-nursery/regex/pull/205):
+* [PR #205](https://github.com/rust-lang/regex/pull/205):
   More improvements to DFA performance. Competitive with RE2. See PR for
   benchmarks.
-* [PR #209](https://github.com/rust-lang-nursery/regex/pull/209):
+* [PR #209](https://github.com/rust-lang/regex/pull/209):
   Release 0.1.66 was semver incompatible since it required a newer version
   of Rust than previous releases. This PR fixes that. (And `0.1.66` was
   yanked.)
@@ -110,11 +110,11 @@
   complexity. It was replaced with a more limited optimization where, given any
   regex of the form `re$`, it will be matched in reverse from the end of the
   haystack.
-* [PR #202](https://github.com/rust-lang-nursery/regex/pull/202):
+* [PR #202](https://github.com/rust-lang/regex/pull/202):
   The inner loop of the DFA was heavily optimized to improve cache locality
   and reduce the overall number of instructions run on each iteration. This
   represents the first use of `unsafe` in `regex` (to elide bounds checks).
-* [PR #200](https://github.com/rust-lang-nursery/regex/pull/200):
+* [PR #200](https://github.com/rust-lang/regex/pull/200):
   Use of the `mempool` crate (which used thread local storage) was replaced
   with a faster version of a similar API in @Amanieu's `thread_local` crate.
   It should reduce contention when using a regex from multiple threads
@@ -124,5 +124,5 @@
   (Includes a comparison with PCRE1's JIT and Oniguruma.)
 * A bug where word boundaries weren't being matched correctly in the DFA was
   fixed. This only affected use of `bytes::Regex`.
-* [#160](https://github.com/rust-lang-nursery/regex/issues/160):
+* [#160](https://github.com/rust-lang/regex/issues/160):
   `Captures` now has a `Debug` impl.

README.md

@@ -7,9 +7,9 @@ linear time with respect to the size of the regular expression and search text.
 Much of the syntax and implementation is inspired
 by [RE2](https://github.com/google/re2).
 
-[![Build Status](https://travis-ci.org/rust-lang-nursery/regex.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/regex)
-[![Build status](https://ci.appveyor.com/api/projects/status/22g48bo866qr4u77?svg=true)](https://ci.appveyor.com/project/alexcrichton/regex)
-[![Coverage Status](https://coveralls.io/repos/github/rust-lang-nursery/regex/badge.svg?branch=master)](https://coveralls.io/github/rust-lang-nursery/regex?branch=master)
+[![Build Status](https://travis-ci.org/rust-lang/regex.svg?branch=master)](https://travis-ci.org/rust-lang/regex)
+[![Build status](https://ci.appveyor.com/api/projects/status/github/rust-lang/regex?svg=true)](https://ci.appveyor.com/project/rust-lang-libs/regex)
+[![Coverage Status](https://coveralls.io/repos/github/rust-lang/regex/badge.svg?branch=master)](https://coveralls.io/github/rust-lang/regex?branch=master)
 [![](http://meritbadge.herokuapp.com/regex)](https://crates.io/crates/regex)
 
 ### Documentation

regex-capi/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["The Rust Project Developers"]
 license = "MIT/Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/rust-lang/regex"
-documentation = "https://github.com/rust-lang-nursery/regex/tree/master/regex-capi"
+documentation = "https://github.com/rust-lang/regex/tree/master/regex-capi"
 homepage = "https://github.com/rust-lang/regex"
 description = """
 A C API for Rust's regular expression library.

regex-capi/README.md

@@ -24,7 +24,7 @@ Assuming you have
 (and a C compiler), then this should work to run the `iter` example:
 
 ```
-$ git clone git://github.com/rust-lang-nursery/regex
+$ git clone git://github.com/rust-lang/regex
 $ cd regex/regex-capi/examples
 $ ./compile
 $ LD_LIBRARY_PATH=../target/release ./iter
@@ -42,7 +42,7 @@ All memory usage is bounded and all searching takes linear time with respect
 to the input string.
 
 For more details, see the PERFORMANCE guide:
-https://github.com/rust-lang-nursery/regex/blob/master/PERFORMANCE.md
+https://github.com/rust-lang/regex/blob/master/PERFORMANCE.md
 
 
 Text encoding

regex-syntax/src/parser.rs

@@ -609,7 +609,7 @@ impl Parser {
             // If `class` was only non-empty due to multibyte characters, the
             // corresponding byte class will now be empty.
             //
-            // See https://github.com/rust-lang-nursery/regex/issues/303
+            // See https://github.com/rust-lang/regex/issues/303
             if byte_class.is_empty() {
                 // e.g., (?-u)[^\x00-\xFF]
                 return Err(self.err(ErrorKind::EmptyClass));

src/backtrack.rs

@@ -44,7 +44,7 @@ pub fn should_exec(num_insts: usize, text_len: usize) -> bool {
     //   ((len(insts) * (len(input) + 1) + bits - 1) / bits) * (size_of(u32))
     //
     // The actual limit picked is pretty much a heuristic.
-    // See: https://github.com/rust-lang-nursery/regex/issues/215
+    // See: https://github.com/rust-lang/regex/issues/215
     let size = ((num_insts * (text_len + 1) + BIT_SIZE - 1) / BIT_SIZE) * 4;
     size <= MAX_SIZE_BYTES
 }

tests/bytes.rs

@@ -41,7 +41,7 @@ mat!(null_bytes, r"(?-u)(?P<cstr>[^\x00]+)\x00",
      R(b"foo\x00"), Some((0, 4)), Some((0, 3)));
 
 // Test that lookahead operators work properly in the face of invalid UTF-8.
-// See: https://github.com/rust-lang-nursery/regex/issues/277
+// See: https://github.com/rust-lang/regex/issues/277
 matiter!(invalidutf8_anchor1,
          r"(?-u)\xcc?^",
          R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
@@ -55,7 +55,7 @@ matiter!(invalidutf8_anchor3,
          R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
          (0, 0));
 
-// See https://github.com/rust-lang-nursery/regex/issues/303
+// See https://github.com/rust-lang/regex/issues/303
 #[test]
 fn negated_full_byte_range() {
      assert!(::regex::bytes::Regex::new(r#"(?-u)[^\x00-\xff]"#).is_err());

tests/regression.rs

@@ -25,58 +25,58 @@ mat!(regression_negated_char_class_2, r"(?i)[^x]", "X", None);
 // See: https://github.com/rust-lang/regex/issues/101
 mat!(regression_ascii_word_underscore, r"[[:word:]]", "_", Some((0, 1)));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/129
+// See: https://github.com/rust-lang/regex/issues/129
 #[test]
 fn regression_captures_rep() {
     let re = regex!(r"([a-f]){2}(?P<foo>[x-z])");
     let caps = re.captures(text!("abx")).unwrap();
     assert_eq!(match_text!(caps.name("foo").unwrap()), text!("x"));
 }
 
-// See: https://github.com/rust-lang-nursery/regex/issues/153
+// See: https://github.com/rust-lang/regex/issues/153
 mat!(regression_alt_in_alt1, r"ab?|$", "az", Some((0, 1)));
 mat!(regression_alt_in_alt2, r"^(.*?)(\n|\r\n?|$)", "ab\rcd", Some((0, 3)));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/169
+// See: https://github.com/rust-lang/regex/issues/169
 mat!(regression_leftmost_first_prefix, r"z*azb", "azb", Some((0, 3)));
 
 // See: https://github.com/rust-lang/regex/issues/76
 mat!(uni_case_lower_nocase_flag, r"(?i)\p{Ll}+", "ΛΘΓΔα", Some((0, 10)));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/191
+// See: https://github.com/rust-lang/regex/issues/191
 mat!(many_alternates, r"1|2|3|4|5|6|7|8|9|10|int", "int", Some((0, 3)));
 
 // burntsushi was bad and didn't create an issue for this bug.
 mat!(anchored_prefix1, r"^a\S", "a ", None);
 mat!(anchored_prefix2, r"^a\S", "foo boo a ", None);
 mat!(anchored_prefix3, r"^-[a-z]", "r-f", None);
 
-// See: https://github.com/rust-lang-nursery/regex/issues/204
+// See: https://github.com/rust-lang/regex/issues/204
 split!(split_on_word_boundary, r"\b", r"Should this (work?)",
        &[t!(""), t!("Should"), t!(" "), t!("this"),
          t!(" ("), t!("work"), t!("?)")]);
 matiter!(word_boundary_dfa, r"\b", "a b c",
          (0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/268
+// See: https://github.com/rust-lang/regex/issues/268
 matiter!(partial_anchor, r"^a|b", "ba", (0, 1));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/264
+// See: https://github.com/rust-lang/regex/issues/264
 mat!(ascii_boundary_no_capture, r"(?-u)\B", "\u{28f3e}", Some((0, 0)));
 mat!(ascii_boundary_capture, r"(?-u)(\B)", "\u{28f3e}", Some((0, 0)));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/280
+// See: https://github.com/rust-lang/regex/issues/280
 ismatch!(partial_anchor_alternate_begin, r"^a|z", "yyyyya", false);
 ismatch!(partial_anchor_alternate_end, r"a$|z", "ayyyyy", false);
 
-// See: https://github.com/rust-lang-nursery/regex/issues/289
+// See: https://github.com/rust-lang/regex/issues/289
 mat!(lits_unambiguous1, r"(ABC|CDA|BC)X", "CDAX", Some((0, 4)));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/291
+// See: https://github.com/rust-lang/regex/issues/291
 mat!(lits_unambiguous2, r"((IMG|CAM|MG|MB2)_|(DSCN|CIMG))(?P<n>[0-9]+)$",
      "CIMG2341", Some((0, 8)), Some((0, 4)), None, Some((0, 4)), Some((4, 8)));
 
-// See: https://github.com/rust-lang-nursery/regex/issues/271
+// See: https://github.com/rust-lang/regex/issues/271
 mat!(end_not_wb, r"$(?-u:\B)", "\u{5c124}\u{b576c}", Some((8, 8)));
 mat!(endl_or_wb, r"(?m:$)|(?-u:\b)", "\u{6084e}", Some((4, 4)));
 mat!(zero_or_end, r"(?i-u:\x00)|$", "\u{e682f}", Some((4, 4)));

tests/set.rs

@@ -20,7 +20,7 @@ nomatset!(nset1, &["a", "a"], "b");
 nomatset!(nset2, &["^foo", "bar$"], "bar foo");
 nomatset!(nset3, { let xs: &[&str] = &[]; xs }, "a");
 
-// See: https://github.com/rust-lang-nursery/regex/issues/187
+// See: https://github.com/rust-lang/regex/issues/187
 #[test]
 fn regression_subsequent_matches() {
     let set = regex_set!(&["ab", "b"]);