html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/futf/src/test.rs

@@ -1,270 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::{Meaning, Byte, classify, decode, all_cont};
-
-use std::borrow::ToOwned;
-use std::io::Write;
-use std_test::Bencher;
-
-#[test]
-fn classify_all_bytes() {
-    for n in 0x00..0x80 { assert_eq!(Byte::classify(n), Some(Byte::Ascii)); }
-    for n in 0x80..0xC0 { assert_eq!(Byte::classify(n), Some(Byte::Cont)); }
-    for n in 0xC0..0xE0 { assert_eq!(Byte::classify(n), Some(Byte::Start(2))); }
-    for n in 0xE0..0xF0 { assert_eq!(Byte::classify(n), Some(Byte::Start(3))); }
-    for n in 0xF0..0xF8 { assert_eq!(Byte::classify(n), Some(Byte::Start(4))); }
-    for n in 0xF8..0xFF { assert_eq!(Byte::classify(n), None); }
-    assert_eq!(Byte::classify(0xFF), None);
-}
-
-#[test]
-fn test_all_cont() {
-    assert!(all_cont(b""));
-    assert!(all_cont(b"\x80"));
-    assert!(all_cont(b"\xBF"));
-    assert!(all_cont(b"\x80\xBF\x80\xBF"));
-
-    assert!(!all_cont(b"z"));
-    assert!(!all_cont(b"\xC0\xBF"));
-    assert!(!all_cont(b"\xFF"));
-    assert!(!all_cont(b"\x80\xBFz\x80\xBF"));
-    assert!(!all_cont(b"\x80\xBF\xC0\x80\xBF"));
-    assert!(!all_cont(b"\x80\xBF\xFF\x80\xBF"));
-    assert!(!all_cont(b"\x80\xBF\x80\xBFz"));
-    assert!(!all_cont(b"\x80\xBF\x80\xBF\xC0"));
-    assert!(!all_cont(b"z\x80\xBF\x80\xBF"));
-    assert!(!all_cont(b"\xC0\x80\xBF\x80\xBF"));
-}
-
-#[test]
-fn test_decode() {
-    unsafe {
-        assert_eq!(Some(Meaning::Whole('ő')), decode(b"\xC5\x91"));
-        assert_eq!(Some(Meaning::Whole('\u{a66e}')), decode(b"\xEA\x99\xAE"));
-        assert_eq!(Some(Meaning::Whole('\u{1f4a9}')), decode(b"\xF0\x9F\x92\xA9"));
-        assert_eq!(Some(Meaning::Whole('\u{10ffff}')), decode(b"\xF4\x8F\xBF\xBF"));
-
-        assert_eq!(Some(Meaning::LeadSurrogate(0x0000)), decode(b"\xED\xA0\x80"));
-        assert_eq!(Some(Meaning::LeadSurrogate(0x0001)), decode(b"\xED\xA0\x81"));
-        assert_eq!(Some(Meaning::LeadSurrogate(0x03FE)), decode(b"\xED\xAF\xBE"));
-        assert_eq!(Some(Meaning::LeadSurrogate(0x03FF)), decode(b"\xED\xAF\xBF"));
-
-        assert_eq!(Some(Meaning::TrailSurrogate(0x0000)), decode(b"\xED\xB0\x80"));
-        assert_eq!(Some(Meaning::TrailSurrogate(0x0001)), decode(b"\xED\xB0\x81"));
-        assert_eq!(Some(Meaning::TrailSurrogate(0x03FE)), decode(b"\xED\xBF\xBE"));
-        assert_eq!(Some(Meaning::TrailSurrogate(0x03FF)), decode(b"\xED\xBF\xBF"));
-
-        // The last 4-byte UTF-8 sequence. This would be U+1FFFFF, which is out of
-        // range.
-        assert_eq!(None, decode(b"\xF7\xBF\xBF\xBF"));
-
-        // First otherwise-valid sequence (would be U+110000) that is out of range
-        assert_eq!(None, decode(b"\xF4\x90\x80\x80"));
-
-        // Overlong sequences
-        assert_eq!(None, decode(b"\xC0\x80"));
-        assert_eq!(None, decode(b"\xC1\xBF"));
-        assert_eq!(None, decode(b"\xE0\x80\x80"));
-        assert_eq!(None, decode(b"\xE0\x9F\xBF"));
-        assert_eq!(None, decode(b"\xF0\x80\x80\x80"));
-        assert_eq!(None, decode(b"\xF0\x8F\xBF\xBF"));
-
-        // For not-overlong sequence for each sequence length
-        assert_eq!(Some(Meaning::Whole('\u{80}')), decode(b"\xC2\x80"));
-        assert_eq!(Some(Meaning::Whole('\u{800}')), decode(b"\xE0\xA0\x80"));
-        assert_eq!(Some(Meaning::Whole('\u{10000}')), decode(b"\xF0\x90\x80\x80"));
-   }
-}
-
-static JUNK: &'static [u8] = b"\
-    \xf8\x0d\x07\x25\xa6\x7b\x95\xeb\x47\x01\x7f\xee\
-    \x3b\x00\x60\x57\x1d\x9e\x5d\x0a\x0b\x0a\x7c\x75\
-    \x13\xa1\x82\x46\x27\x34\xe9\x52\x61\x0d\xec\x10\
-    \x54\x49\x6e\x54\xdf\x7b\xe1\x31\x8c\x06\x21\x83\
-    \x0f\xb5\x1f\x4c\x6a\x71\x52\x42\x74\xe7\x7b\x50\
-    \x59\x1f\x6a\xd4\xff\x06\x92\x33\xc4\x34\x97\xff\
-    \xcc\xb5\xc4\x00\x7b\xc3\x4a\x7f\x7e\x63\x96\x58\
-    \x51\x63\x21\x54\x53\x2f\x03\x8a\x7d\x41\x79\x98\
-    \x5b\xcb\xb8\x94\x6b\x73\xf3\x0c\x5a\xd7\xc4\x12\
-    \x7a\x2b\x9a\x2e\x67\x62\x2a\x00\x45\x2c\xfe\x7d\
-    \x8d\xd6\x51\x4e\x59\x36\x72\x1b\xae\xaa\x06\xe8\
-    \x71\x1b\x85\xd3\x35\xb5\xbe\x9e\x16\x96\x72\xd8\
-    \x1a\x48\xba\x4d\x55\x4f\x1b\xa2\x77\xfa\x8f\x71\
-    \x58\x7d\x03\x93\xa2\x3a\x76\x51\xda\x48\xe2\x3f\
-    \xeb\x8d\xda\x89\xae\xf7\xbd\x3d\xb6\x37\x97\xca\
-    \x99\xcc\x4a\x8d\x62\x89\x97\xe3\xc0\xd1\x8d\xc1\
-    \x26\x11\xbb\x8d\x53\x61\x4f\x76\x03\x00\x30\xd3\
-    \x5f\x86\x19\x52\x9c\x3e\x99\x8c\xb7\x21\x48\x1c\
-    \x85\xae\xad\xd5\x74\x00\x6c\x3e\xd0\x17\xff\x76\
-    \x5c\x32\xc3\xfb\x24\x99\xd4\x4c\xa4\x1f\x66\x46\
-    \xe7\x2d\x44\x56\x7d\x14\xd9\x76\x91\x37\x2f\xb7\
-    \xcc\x1b\xd3\xc2";
-
-#[test]
-fn classify_whole() {
-    assert_eq!(JUNK.len(), 256);
-
-    for &c in &['\0', '\x01', 'o', 'z', 'ő', '\u{2764}',
-                '\u{a66e}', '\u{1f4a9}', '\u{1f685}'] {
-        for idx in 0 .. JUNK.len() - 3 {
-            let mut buf = JUNK.to_owned();
-            let ch = format!("{}", c).into_bytes();
-            (&mut buf[idx..]).write_all(&ch).unwrap();
-
-            for j in 0 .. ch.len() {
-                let class = classify(&buf, idx+j).unwrap();
-                assert_eq!(class.bytes, &*ch);
-                assert_eq!(class.rewind, j);
-                assert_eq!(class.meaning, Meaning::Whole(c));
-            }
-        }
-    }
-}
-
-#[test]
-fn classify_surrogates() {
-    for &(s, b) in &[
-        (Meaning::LeadSurrogate(0x0000), b"\xED\xA0\x80"),
-        (Meaning::LeadSurrogate(0x0001), b"\xED\xA0\x81"),
-        (Meaning::LeadSurrogate(0x03FE), b"\xED\xAF\xBE"),
-        (Meaning::LeadSurrogate(0x03FF), b"\xED\xAF\xBF"),
-
-        (Meaning::TrailSurrogate(0x0000), b"\xED\xB0\x80"),
-        (Meaning::TrailSurrogate(0x0001), b"\xED\xB0\x81"),
-        (Meaning::TrailSurrogate(0x03FE), b"\xED\xBF\xBE"),
-        (Meaning::TrailSurrogate(0x03FF), b"\xED\xBF\xBF"),
-    ] {
-        for idx in 0 .. JUNK.len() - 2 {
-            let mut buf = JUNK.to_owned();
-            (&mut buf[idx..]).write_all(b).unwrap();
-
-            let class = classify(&buf, idx).unwrap();
-            assert_eq!(class.bytes, b);
-            assert_eq!(class.rewind, 0);
-            assert_eq!(class.meaning, s);
-        }
-    }
-}
-
-#[test]
-fn classify_prefix_suffix() {
-    for &c in &['ő', '\u{a66e}', '\u{1f4a9}'] {
-        let ch = format!("{}", c).into_bytes();
-        for pfx in 1 .. ch.len() - 1 {
-            let mut buf = JUNK.to_owned();
-            let buflen = buf.len();
-            (&mut buf[buflen - pfx .. buflen]).write_all(&ch[..pfx]).unwrap();
-            for j in 0 .. pfx {
-                let idx = buflen - 1 - j;
-                let class = classify(&buf, idx).unwrap();
-                assert_eq!(class.bytes, &ch[..pfx]);
-                assert_eq!(class.rewind, pfx - 1 - j);
-                assert_eq!(class.meaning, Meaning::Prefix(ch.len() - pfx));
-            }
-        }
-        for sfx in 1 .. ch.len() - 1 {
-            let ch_bytes = &ch[ch.len() - sfx ..];
-            let mut buf = JUNK.to_owned();
-            (&mut *buf).write_all(ch_bytes).unwrap();
-            for j in 0 .. sfx {
-                let class = classify(&buf, j).unwrap();
-                assert!(ch_bytes.starts_with(class.bytes));
-                assert_eq!(class.rewind, j);
-                assert_eq!(class.meaning, Meaning::Suffix);
-            }
-        }
-    }
-}
-
-#[test]
-fn out_of_bounds() {
-    assert!(classify(b"", 0).is_none());
-    assert!(classify(b"", 7).is_none());
-    assert!(classify(b"aaaaaaa", 7).is_none());
-}
-
-#[test]
-fn malformed() {
-    assert_eq!(None, classify(b"\xFF", 0));
-    assert_eq!(None, classify(b"\xC5\xC5", 0));
-    assert_eq!(None, classify(b"x\x91", 1));
-    assert_eq!(None, classify(b"\x91\x91\x91\x91", 3));
-    assert_eq!(None, classify(b"\x91\x91\x91\x91\x91", 4));
-    assert_eq!(None, classify(b"\xEA\x91\xFF", 1));
-    assert_eq!(None, classify(b"\xF0\x90\x90\xF0", 0));
-    assert_eq!(None, classify(b"\xF0\x90\x90\xF0", 1));
-    assert_eq!(None, classify(b"\xF0\x90\x90\xF0", 2));
-
-    for i in 0..4 {
-        // out of range: U+110000
-        assert_eq!(None, classify(b"\xF4\x90\x80\x80", i));
-
-        // out of range: U+1FFFFF
-        assert_eq!(None, classify(b"\xF7\xBF\xBF\xBF", i));
-
-        // Overlong sequences
-        assert_eq!(None, classify(b"\xC0\x80", i));
-        assert_eq!(None, classify(b"\xC1\xBF", i));
-        assert_eq!(None, classify(b"\xE0\x80\x80", i));
-        assert_eq!(None, classify(b"\xE0\x9F\xBF", i));
-        assert_eq!(None, classify(b"\xF0\x80\x80\x80", i));
-        assert_eq!(None, classify(b"\xF0\x8F\xBF\xBF", i));
-    }
-}
-
-static TEXT: &'static str = "
-    All human beings are born free and equal in dignity and rights.
-    They are endowed with reason and conscience and should act
-    towards one another in a spirit of brotherhood.
-
-    Minden emberi lény szabadon születik és egyenlő méltósága és
-    joga van. Az emberek, ésszel és lelkiismerettel bírván,
-    egymással szemben testvéri szellemben kell hogy viseltessenek.
-
-    เราทุกคนเกิดมาอย่างอิสระ เราทุกคนมีความคิดและความเข้าใจเป็นของเราเอง
-    เราทุกคนควรได้รับการปฏิบัติในทางเดียวกัน.
-
-    모든 인간은 태어날 때부터 자유로우며 그 존엄과 권리에 있어
-    동등하다. 인간은 천부적으로 이성과 양심을 부여받았으며 서로
-    형제애의 정신으로 행동하여야 한다.
-
-    ro remna cu se jinzi co zifre je simdu'i be le ry. nilselsi'a
-    .e lei ry. selcru .i ry. se menli gi'e se sezmarde .i .ei
-    jeseki'ubo ry. simyzu'e ta'i le tunba
-
-    ᏂᎦᏓ ᎠᏂᏴᏫ ᏂᎨᎫᏓᎸᎾ ᎠᎴ ᎤᏂᏠᏱ ᎤᎾᏕᎿ ᏚᏳᎧᏛ ᎨᏒᎢ. ᎨᏥᏁᎳ ᎤᎾᏓᏅᏖᏗ ᎠᎴ ᎤᏃᏟᏍᏗ
-    ᎠᎴ ᏌᏊ ᎨᏒ ᏧᏂᎸᏫᏍᏓᏁᏗ ᎠᎾᏟᏅᏢ ᎠᏓᏅᏙ ᎬᏗ.";
-
-// random
-static IXES: &'static [usize]
-    = &[778, 156, 87, 604, 1216, 365, 884, 311,
-        469, 515, 709, 162, 871, 206, 634, 442];
-
-static BOUNDARY: &'static [bool]
-    = &[false, true, true, false, false, true, true, true,
-        true, false, false, true, true, true, false, false];
-
-#[bench]
-fn std_utf8_check(b: &mut Bencher) {
-    b.iter(|| {
-        assert!(IXES.iter().zip(BOUNDARY.iter()).all(|(&ix, &expect)| {
-            expect == TEXT.is_char_boundary(ix)
-        }));
-    });
-}
-
-// We don't expect to be as fast as is_char_boundary, because we provide more
-// information. But we shouldn't be tremendously slower, either. A factor of
-// 5-10 is expected on this text.
-#[bench]
-fn futf_check(b: &mut Bencher) {
-    b.iter(|| {
-        assert!(IXES.iter().zip(BOUNDARY.iter()).all(|(&ix, &expect)| {
-            expect == (::classify(TEXT.as_bytes(), ix).unwrap().rewind == 0)
-        }));
-    });
-}

data/rust-vendor/html5ever/examples/capi/tokenize.c

@@ -1,74 +0,0 @@
-// Copyright 2014-2017 The html5ever Project Developers. See the
-// COPYRIGHT file at the top-level directory of this distribution.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#include <stdio.h>
-
-#include "html5ever.h"
-
-void put_str(const char *x) {
-    fputs(x, stdout);
-}
-
-void put_buf(struct h5e_buf text) {
-    fwrite(text.data, text.len, 1, stdout);
-}
-
-void do_chars(void *user, struct h5e_buf text) {
-    put_str("CHARS : ");
-    put_buf(text);
-    put_str("\n");
-}
-
-void do_start_tag(void *user, struct h5e_buf name, int self_closing, size_t num_attrs) {
-    put_str("TAG   : <");
-    put_buf(name);
-    if (self_closing) {
-        putchar('/');
-    }
-    put_str(">\n");
-}
-
-void do_tag_attr(void *user, struct h5e_buf name, struct h5e_buf value) {
-    put_str("  ATTR: ");
-    put_buf(name);
-    put_str("=\"");
-    put_buf(value);
-    put_str("\"\n");
-}
-
-void do_end_tag(void *user, struct h5e_buf name) {
-    put_str("TAG   : </");
-    put_buf(name);
-    put_str(">\n");
-}
-
-struct h5e_token_ops ops = {
-    .do_chars = do_chars,
-    .do_start_tag = do_start_tag,
-    .do_tag_attr = do_tag_attr,
-    .do_end_tag = do_end_tag,
-};
-
-struct h5e_token_sink sink = {
-    .ops = &ops,
-    .user = NULL,
-};
-
-int main(int argc, char *argv[]) {
-    if (argc < 2) {
-        printf("Usage: %s 'HTML fragment'\n", argv[0]);
-        return 1;
-    }
-
-    struct h5e_tokenizer *tok = h5e_tokenizer_new(&sink);
-    h5e_tokenizer_feed(tok, h5e_buf_from_cstr(argv[1]));
-    h5e_tokenizer_end(tok);
-    h5e_tokenizer_free(tok);
-    return 0;
-}

data/rust-vendor/mac/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{".travis.yml":"180cc837b1ea2ce0ed737c2e15208e83abf6f92291a77ed1ebcc564c628c2077","Cargo.toml":"6d465c5e5a4b3e197049e9fb7393b2f996c1c654e6ded700afce046fac2f7969","README.md":"8edb7a912d295acf1e1cfeafdd19a6813a63b301c7bbfda3c67f65509bd8d8cc","src/cfg.rs":"63e9c4da8b0f588c6af1e157e626044fc1fb52757348aa466d08d69795335f33","src/format.rs":"3c528949cdde598d3ddc5abea31b136ca256c7bb3932e053c5ff6e49775579a3","src/inspect.rs":"cf039cc721daa177b13d6b432589ceef3bdfa6078af3f71c34c28d2eca68d0c3","src/lib.rs":"f9c7705196f71dcabb4cfe1636f1b71b6362abb7eac70ddaa6e05cf9a0683dee","src/matches.rs":"1ef2b80946cc5e3cd15e20a22f62b832066d2e2445881191741a83abe80e7566","src/mem.rs":"f74d9172bb136b370c33fa524aae3543cf37815eeacf1d862b29b3c8c32a6aee","src/syntax_ext.rs":"5c938b44d7aaa0f47eef495f4a42f1f91cd11fb0d1b20915786085b77e1db284","src/test.rs":"895fc0aed7f5f3863025b85de4d01c2551bed51778ca8846920be7febff837ac"},"package":"c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"}

data/rust-vendor/mac/.travis.yml

@@ -1,19 +0,0 @@
-language: rust
-sudo: false
-
-script:
-    - cargo build
-    - cargo test
-    - cargo bench --no-run
-    - cargo doc
-
-after_success:
-    - if [ "$TRAVIS_PULL_REQUEST" == false && test == "TRAVIS_BRANCH" == "master" ]; then
-    - curl https://raw.githubusercontent.com/reem/rust-gh-docs/master/make-docs.sh > docs.sh
-    - chmod u+x docs.sh
-    - ./docs.sh reem project-name
-
-env:
-  global:
-    secure: QPYL1XUr4CyK/2DXlsYC1eCpWRpyEiqQSd/FFVR+YdP/rOJ7AyAXQqPhfgjDBQwvc6E2fUiyYjoV/xe1a757DDeZKlgd8Lp20fSDwvNt/Ejx8ueh3h3kuOtgDpIGSKX/l+XC+ltDpzjhh7bowI2/fOEf+kE53jvu9i4PiLnKdlY=
-

data/rust-vendor/mac/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-
-name = "mac"
-version = "0.1.1"
-authors = ["Jonathan Reem <jonathan.reem@gmail.com>"]
-repository = "https://github.com/reem/rust-mac.git"
-description = "A collection of great and ubiqutitous macros."
-readme = "README.md"
-license = "MIT/Apache-2.0"
-

data/rust-vendor/mac/README.md

@@ -1,27 +0,0 @@
-# mac
-
-> A collection of great and ubiqutitous macros.
-
-## Overview
-
-This crate contains collections of macros which are useful in many situations,
-and usable independently or together.
-
-## Usage
-
-Use the crates.io repository; add this to your `Cargo.toml` along
-with the rest of your dependencies:
-
-```toml
-[dependencies]
-mac = "*"
-```
-
-## Author
-
-[Jonathan Reem](https://medium.com/@jreem) is the primary author and maintainer of mac.
-
-## License
-
-MIT/Apache-2.0, like rust itself
-

data/rust-vendor/mac/src/cfg.rs

@@ -1,90 +0,0 @@
-//! Macros for conditional compilation.
-
-/// Compile-time matching on config variables.
-///
-/// Only the branch relevant on your machine will be type-checked!
-///
-/// # Example
-///
-/// ```
-/// # #[macro_use] extern crate mac;
-/// # fn main() {
-/// let mascot = match_cfg! {
-///     (target_os = "linux") => "penguin",
-///     (target_os = "openbsd") => "blowfish",
-///     _ => "unknown",
-/// };
-/// println!("{}", mascot);
-/// # }
-/// ```
-///
-#[macro_export]
-macro_rules! match_cfg {
-    ( $( ($cfg:meta) => $e:expr, )* _ => $last:expr, ) => {
-        match () {
-            $(
-                #[cfg($cfg)]
-                () => $e,
-            )*
-
-            #[cfg(all( $( not($cfg) ),* ))]
-            () => $last,
-        }
-    };
-
-    ( $( ($cfg:meta) => $e:expr, )* ) => {
-        match_cfg! {
-            $(
-                ($cfg) => $e,
-            )*
-
-            _ => {
-                #[allow(dead_code)]
-                #[static_assert]
-                static MATCH_CFG_FALLBACK_UNREACHABLE: bool = false;
-            }
-        }
-    };
-}
-
-/// Compile-time conditional expression.
-///
-/// # Example
-///
-/// ```
-/// # #[macro_use] extern crate mac;
-/// # fn main() {
-/// if_cfg!(test {
-///     println!("Crate built as a test suite");
-/// })
-/// # }
-/// ```
-///
-/// Unlike `if cfg!(...)`, this will not even compile the unused branch.
-///
-/// ```
-/// # #[macro_use] extern crate mac;
-/// # fn main() {
-/// let x = if_cfg!(any(bleh, blah="bluh") {
-///     some_undefined_function_name();
-///     2 + "doesn't even typecheck"
-/// } else {
-///     3
-/// });
-///
-/// assert_eq!(x, 3);
-/// # }
-/// ```
-#[macro_export]
-macro_rules! if_cfg {
-    ($cfg:meta $t:block else $f:block) => {
-        match_cfg! {
-            ($cfg) => $t,
-            _ => $f,
-        }
-    };
-
-    ($cfg:meta $t:block) => {
-        if_cfg!($cfg $t else { })
-    };
-}

data/rust-vendor/mac/src/format.rs

@@ -1,50 +0,0 @@
-//! Macros for string formatting.
-
-/// Conditionally perform string formatting.
-///
-/// If `$enabled` is true, then do the formatting and return a `Cow::Owned`.
-///
-/// Otherwise, just return the borrowed (often `'static`) string
-/// `$borrowed`.
-///
-/// When `$enabled` is false, this avoids the overhead of allocating
-/// and writing to a buffer, as well as any overhead or side effects
-/// of the format arguments.
-///
-/// # Example
-///
-/// You can use `format_if` to implement a detailed error logging facility
-/// that can be enabled at runtime.
-///
-/// ```
-/// # #[macro_use] extern crate mac;
-/// # use std::borrow::Cow::{Borrowed, Owned};
-/// # fn main() {
-/// let formatted = format_if!(true, "Vague error", "Error code {:?}", 3);
-///
-/// assert_eq!(&formatted[..], "Error code 3");
-/// if let Borrowed(_) = formatted {
-///     panic!("Wrong!")
-/// }
-///
-/// let not_formatted = format_if!(false, "Vague error", "Error code {:?}", {
-///     // Note that the argument is not evaluated.
-///     panic!("oops");
-/// });
-///
-/// assert_eq!(&not_formatted[..], "Vague error");
-/// if let Owned(_) = not_formatted {
-///     panic!("Wrong!")
-/// }
-/// # }
-/// ```
-#[macro_export]
-macro_rules! format_if {
-    ($enabled:expr, $borrowed:expr, $fmt:expr, $($args:expr),*) => {
-        if $enabled {
-            ::std::borrow::Cow::Owned(format!($fmt, $($args),*)) as ::std::borrow::Cow<str>
-        } else {
-            ::std::borrow::Cow::Borrowed($borrowed)
-        }
-    }
-}

data/rust-vendor/mac/src/inspect.rs

@@ -1,93 +0,0 @@
-//! Inspect Macros
-
-/// Evaluates an expression, prints a stringified version of the expression
-/// along with the evaluated value, and then returns that value.
-///
-/// # Example
-///
-/// ```
-/// # #[macro_use] extern crate mac;
-///
-/// # fn main() {
-/// fn lcm_2_to_4() -> u32 {
-///     let mut i = 1;
-///     loop {
-///         if inspect!(i % 2, i % 3, i % 4) == (0, 0, 0) {
-///             return inspect!("done: i = " => i);
-///         }
-///         i += 1;
-///     }
-/// }
-/// assert_eq!(lcm_2_to_4(), 12);
-/// # }
-/// ```
-///
-/// Returns `12`, and prints the following to stdout:
-///
-/// ```ignore
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (1, 1, 1)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (0, 2, 2)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (1, 0, 3)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (0, 1, 0)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (1, 2, 1)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (0, 0, 2)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (1, 1, 3)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (0, 2, 0)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (1, 0, 1)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (0, 1, 2)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (1, 2, 3)
-/// src/inspect.rs:94 - (i % 2, i % 3, i % 4) = (0, 0, 0)
-/// src/inspect.rs:95 - done: i = 12
-/// ```
-
-#[macro_export]
-macro_rules! inspect {
-    ($prefix:expr => $expr:expr) => {{
-        let val = $expr;
-        println!("{}:{} - {}{:?}", file!(), line!(), $prefix, val);
-        val
-    }};
-    ($expr:expr) => {
-        inspect!(concat!(stringify!($expr), " = ") => $expr)
-    };
-    ($prefix:expr => $($expr:expr),+) => {
-        inspect!($prefix => ($($expr),+))
-    };
-    ($($expr:expr),+) => {
-        inspect!(($($expr),+))
-    };
-}
-
-#[test]
-fn test_inspect() {
-    assert_eq!(inspect!("foo"), "foo");
-    assert_eq!(inspect!("" => "foo"), "foo");
-    assert_eq!(inspect!(1 + 2, 2 + 3, 3 + 4), (3, 5, 7));
-    assert_eq!(inspect!("" => 1 + 2, 2 + 3, 3 + 4), (3, 5, 7));
-
-    fn fib(n: u64) -> u64 {
-        inspect!("fib :: n = " => n);
-        inspect! { "ret = " => match n {
-            0 | 1 => n,
-            n => fib(n-1) + fib(n-2)
-        }}
-    }
-
-    fn fib_iter(n: u64) -> u64 {
-        inspect!("fib_iter :: n = " => n);
-        let (mut a, mut b) = (0, 1);
-        for _ in 0..n {
-            inspect!(a, b);
-            let tmp = b;
-            b += a;
-            a = tmp;
-        }
-        inspect!("ret = " => a)
-    }
-
-    assert_eq!(fib(4), 3);
-    assert_eq!(fib_iter(7), 13);
-
-    // Uncomment the following to see the output in `cargo test`.
-    // panic!()
-}