Try #1:

Author: bors[bot]

.buildbot.sh

@@ -0,0 +1,21 @@
+#! /bin/sh
+
+set -e
+
+export CARGO_HOME="`pwd`/.cargo"
+export RUSTUP_HOME="`pwd`/.rustup"
+
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup.sh
+sh rustup.sh --default-host x86_64-unknown-linux-gnu --default-toolchain stable -y --no-modify-path
+
+export PATH=`pwd`/.cargo/bin/:$PATH
+
+cargo fmt --all -- --check
+cargo test
+
+which cargo-deny | cargo install cargo-deny || true
+if [ "X`which cargo-deny`" != "X"]; then
+    cargo-deny check license
+else
+    echo "Warning: couldn't run cargo-deny" > /dev/stderr
+fi

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "depub"
+version = "0.1.0"
+authors = ["Laurence Tratt <laurie@tratt.net>"]
+edition = "2018"
+readme = "README.md"
+license = "Apache-2.0 OR MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+getopts = "0.2"
+regex = "1.4"

LICENSE-APACHE

@@ -0,0 +1,10 @@
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.  You may obtain a copy of the
+License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations under the License.

LICENSE-MIT

@@ -0,0 +1,17 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,21 @@
-# depub
+# depub: minimise visibility
+
+When working on medium or large sized Rust code bases, it can be hard to know
+whether the visibility of functions, structs, and so on are still at the
+minimum required. For example, sometimes functions that once needed to be `pub`
+now only need to be `pub(crate)`.
+
+`depub` minimises the visibility of such elements in a code base: in essence,
+it does a string search for `pub`, replaces it with `pub crate` and sees if a
+test command still succeeds. If it does, it keeps that visibility; otherwise it
+tries the next in the list. As this suggests, `depub` is destructive: it
+overwrites files, so do not run it on source code that you do not want altered!
+
+A standard way to run it is:
+
+```
+$ cargo run depub -- -c "cargo check"
+```
+
+`depub` informs you of its progress. After it is finished, `diff` your code
+base, and accept those of its recommendations you think appropriate.

bors.toml

@@ -0,0 +1,6 @@
+status = ["buildbot/buildbot-build-script"]
+
+timeout_sec = 300 # 10 minutes
+
+# Have bors delete auto-merged branches
+delete_merged_branches = true

src/main.rs

@@ -0,0 +1,122 @@
+use getopts::Options;
+use regex::RegexBuilder;
+use std::{
+    env,
+    fs::{read_to_string, write},
+    io::{stdout, Write},
+    path::Path,
+    process::{self, Command, Stdio},
+};
+
+enum PubKind {
+    Pub,
+    Crate,
+    Super,
+    Private,
+}
+
+fn process(cmd: &str, p: &Path) {
+    let pub_regex = RegexBuilder::new("pub(?:\\s*\\(\\s*(.*?)\\s*\\))?")
+        .multi_line(true)
+        .build()
+        .unwrap();
+    let mut cur_txt = read_to_string(p).unwrap();
+    let mut i = 0;
+    let mut cl = pub_regex.capture_locations();
+    while i < cur_txt.len() {
+        print!(".");
+        stdout().flush().ok();
+        let old_txt = cur_txt.clone();
+        let m = match pub_regex.captures_read_at(&mut cl, &old_txt, i) {
+            Some(m) => m,
+            None => break,
+        };
+        let mut kind = if let Some((start, end)) = cl.get(1) {
+            match &cur_txt[start..end] {
+                "crate" => PubKind::Crate,
+                "super" => PubKind::Super,
+                _ => todo!(),
+            }
+        } else {
+            PubKind::Pub
+        };
+        let mut next_txt = cur_txt.clone();
+        loop {
+            let next_kind = match kind {
+                PubKind::Pub => PubKind::Crate,
+                PubKind::Crate => PubKind::Super,
+                PubKind::Super => PubKind::Private,
+                PubKind::Private => break,
+            };
+            let mut try_txt = cur_txt[..m.start()].to_string();
+            let pub_txt = match next_kind {
+                PubKind::Crate => "pub(crate) ",
+                PubKind::Super => "pub(super) ",
+                PubKind::Private => "",
+                _ => unreachable!(),
+            };
+            try_txt.push_str(&pub_txt);
+            try_txt.push_str(&cur_txt[m.end()..]);
+            write(p, &try_txt).unwrap();
+            match Command::new("sh")
+                .arg("-c")
+                .arg(cmd)
+                .stderr(Stdio::null())
+                .stdout(Stdio::null())
+                .status()
+            {
+                Ok(s) if s.success() => {
+                    next_txt = try_txt;
+                }
+                _ => break,
+            }
+            kind = next_kind;
+        }
+        cur_txt = next_txt;
+        if cur_txt.len() >= old_txt.len() {
+            i += m.end() + (cur_txt.len() - old_txt.len());
+        } else {
+            i += m.end() - (old_txt.len() - cur_txt.len());
+        }
+    }
+    write(p, cur_txt).unwrap();
+}
+
+fn progname() -> String {
+    match env::current_exe() {
+        Ok(p) => p
+            .file_name()
+            .map(|x| x.to_str().unwrap_or("depub"))
+            .unwrap_or("depub")
+            .to_owned(),
+        Err(_) => "depub".to_owned(),
+    }
+}
+
+/// Print out program usage then exit. This function must not be called after daemonisation.
+fn usage() -> ! {
+    eprintln!(
+        "Usage: {} -c <command> file_1 [... file_n]",
+        progname = progname()
+    );
+    process::exit(1)
+}
+
+fn main() {
+    let matches = Options::new()
+        .reqopt("c", "command", "Command to execute.", "string")
+        .optflag("h", "help", "")
+        .parse(env::args().skip(1))
+        .unwrap_or_else(|_| usage());
+    if matches.opt_present("h") || matches.free.is_empty() {
+        usage();
+    }
+
+    let cmd_str = matches.opt_str("c").unwrap();
+    for p in matches.free {
+        print!("{}: ", p);
+        stdout().flush().ok();
+        process(cmd_str.as_str(), &Path::new(&p));
+        println!("");
+    }
+}