Use pub(crate) instead of pub (#471)

Eventually, there will probably be a `crate` visibility specifier that
does the same thing as `pub(crate)`. This commit replaces `pub` with
`pub(crate)`, so when `crate` is available we can easily switch to it.

Author: casey

src/alias.rs

@@ -1,11 +1,11 @@
 use crate::common::*;
 
 #[derive(Debug)]
-pub struct Alias<'a> {
-  pub name: &'a str,
-  pub target: &'a str,
-  pub line_number: usize,
-  pub private: bool,
+pub(crate) struct Alias<'a> {
+  pub(crate) name: &'a str,
+  pub(crate) target: &'a str,
+  pub(crate) line_number: usize,
+  pub(crate) private: bool,
 }
 
 impl<'a> Display for Alias<'a> {

src/alias_resolver.rs

@@ -1,7 +1,7 @@
 use crate::common::*;
 use CompilationErrorKind::*;
 
-pub struct AliasResolver<'a, 'b>
+pub(crate) struct AliasResolver<'a, 'b>
 where
   'a: 'b,
 {
@@ -11,7 +11,7 @@ where
 }
 
 impl<'a: 'b, 'b> AliasResolver<'a, 'b> {
-  pub fn resolve_aliases(
+  pub(crate) fn resolve_aliases(
     aliases: &BTreeMap<&'a str, Alias<'a>>,
     recipes: &BTreeMap<&'a str, Recipe<'a>>,
     alias_tokens: &BTreeMap<&'a str, Token<'a>>,

src/assignment_evaluator.rs

@@ -1,20 +1,20 @@
 use crate::common::*;
 
-pub struct AssignmentEvaluator<'a: 'b, 'b> {
-  pub assignments: &'b BTreeMap<&'a str, Expression<'a>>,
-  pub invocation_directory: &'b Result<PathBuf, String>,
-  pub dotenv: &'b BTreeMap<String, String>,
-  pub dry_run: bool,
-  pub evaluated: BTreeMap<&'a str, String>,
-  pub exports: &'b BTreeSet<&'a str>,
-  pub overrides: &'b BTreeMap<&'b str, &'b str>,
-  pub quiet: bool,
-  pub scope: &'b BTreeMap<&'a str, String>,
-  pub shell: &'b str,
+pub(crate) struct AssignmentEvaluator<'a: 'b, 'b> {
+  pub(crate) assignments: &'b BTreeMap<&'a str, Expression<'a>>,
+  pub(crate) invocation_directory: &'b Result<PathBuf, String>,
+  pub(crate) dotenv: &'b BTreeMap<String, String>,
+  pub(crate) dry_run: bool,
+  pub(crate) evaluated: BTreeMap<&'a str, String>,
+  pub(crate) exports: &'b BTreeSet<&'a str>,
+  pub(crate) overrides: &'b BTreeMap<&'b str, &'b str>,
+  pub(crate) quiet: bool,
+  pub(crate) scope: &'b BTreeMap<&'a str, String>,
+  pub(crate) shell: &'b str,
 }
 
 impl<'a, 'b> AssignmentEvaluator<'a, 'b> {
-  pub fn evaluate_assignments(
+  pub(crate) fn evaluate_assignments(
     assignments: &BTreeMap<&'a str, Expression<'a>>,
     invocation_directory: &Result<PathBuf, String>,
     dotenv: &'b BTreeMap<String, String>,
@@ -43,7 +43,7 @@ impl<'a, 'b> AssignmentEvaluator<'a, 'b> {
     Ok(evaluator.evaluated)
   }
 
-  pub fn evaluate_line(
+  pub(crate) fn evaluate_line(
     &mut self,
     line: &[Fragment<'a>],
     arguments: &BTreeMap<&str, Cow<str>>,
@@ -81,7 +81,7 @@ impl<'a, 'b> AssignmentEvaluator<'a, 'b> {
     Ok(())
   }
 
-  pub fn evaluate_expression(
+  pub(crate) fn evaluate_expression(
     &mut self,
     expression: &Expression<'a>,
     arguments: &BTreeMap<&str, Cow<str>>,

src/assignment_resolver.rs

@@ -2,7 +2,7 @@ use crate::common::*;
 
 use CompilationErrorKind::*;
 
-pub struct AssignmentResolver<'a: 'b, 'b> {
+pub(crate) struct AssignmentResolver<'a: 'b, 'b> {
   assignments: &'b BTreeMap<&'a str, Expression<'a>>,
   assignment_tokens: &'b BTreeMap<&'a str, Token<'a>>,
   stack: Vec<&'a str>,
@@ -11,7 +11,7 @@ pub struct AssignmentResolver<'a: 'b, 'b> {
 }
 
 impl<'a: 'b, 'b> AssignmentResolver<'a, 'b> {
-  pub fn resolve_assignments(
+  pub(crate) fn resolve_assignments(
     assignments: &BTreeMap<&'a str, Expression<'a>>,
     assignment_tokens: &BTreeMap<&'a str, Token<'a>>,
   ) -> CompilationResult<'a, ()> {

src/color.rs

@@ -5,7 +5,7 @@ use ansi_term::{ANSIGenericString, Prefix, Style, Suffix};
 use atty::Stream;
 
 #[derive(Copy, Clone)]
-pub struct Color {
+pub(crate) struct Color {
   use_color: UseColor,
   atty: bool,
   style: Style,
@@ -31,96 +31,96 @@ impl Color {
     }
   }
 
-  pub fn fmt(fmt: &Formatter) -> Color {
+  pub(crate) fn fmt(fmt: &Formatter) -> Color {
     if fmt.alternate() {
       Color::always()
     } else {
       Color::never()
     }
   }
 
-  pub fn auto() -> Color {
+  pub(crate) fn auto() -> Color {
     Color {
       use_color: UseColor::Auto,
       ..default()
     }
   }
 
-  pub fn always() -> Color {
+  pub(crate) fn always() -> Color {
     Color {
       use_color: UseColor::Always,
       ..default()
     }
   }
 
-  pub fn never() -> Color {
+  pub(crate) fn never() -> Color {
     Color {
       use_color: UseColor::Never,
       ..default()
     }
   }
 
-  pub fn stderr(self) -> Color {
+  pub(crate) fn stderr(self) -> Color {
     self.redirect(Stream::Stderr)
   }
 
-  pub fn stdout(self) -> Color {
+  pub(crate) fn stdout(self) -> Color {
     self.redirect(Stream::Stdout)
   }
 
-  pub fn doc(self) -> Color {
+  pub(crate) fn doc(self) -> Color {
     self.restyle(Style::new().fg(Blue))
   }
 
-  pub fn error(self) -> Color {
+  pub(crate) fn error(self) -> Color {
     self.restyle(Style::new().fg(Red).bold())
   }
 
-  pub fn warning(self) -> Color {
+  pub(crate) fn warning(self) -> Color {
     self.restyle(Style::new().fg(Yellow).bold())
   }
 
-  pub fn banner(self) -> Color {
+  pub(crate) fn banner(self) -> Color {
     self.restyle(Style::new().fg(Cyan).bold())
   }
 
-  pub fn command(self) -> Color {
+  pub(crate) fn command(self) -> Color {
     self.restyle(Style::new().bold())
   }
 
-  pub fn parameter(self) -> Color {
+  pub(crate) fn parameter(self) -> Color {
     self.restyle(Style::new().fg(Cyan))
   }
 
-  pub fn message(self) -> Color {
+  pub(crate) fn message(self) -> Color {
     self.restyle(Style::new().bold())
   }
 
-  pub fn annotation(self) -> Color {
+  pub(crate) fn annotation(self) -> Color {
     self.restyle(Style::new().fg(Purple))
   }
 
-  pub fn string(self) -> Color {
+  pub(crate) fn string(self) -> Color {
     self.restyle(Style::new().fg(Green))
   }
 
-  pub fn active(&self) -> bool {
+  pub(crate) fn active(&self) -> bool {
     match self.use_color {
       UseColor::Always => true,
       UseColor::Never => false,
       UseColor::Auto => self.atty,
     }
   }
 
-  pub fn paint<'a>(&self, text: &'a str) -> ANSIGenericString<'a, str> {
+  pub(crate) fn paint<'a>(&self, text: &'a str) -> ANSIGenericString<'a, str> {
     self.effective_style().paint(text)
   }
 
-  pub fn prefix(&self) -> Prefix {
+  pub(crate) fn prefix(&self) -> Prefix {
     self.effective_style().prefix()
   }
 
-  pub fn suffix(&self) -> Suffix {
+  pub(crate) fn suffix(&self) -> Suffix {
     self.effective_style().suffix()
   }
 }

src/command_ext.rs

@@ -1,6 +1,6 @@
 use crate::common::*;
 
-pub trait CommandExt {
+pub(crate) trait CommandExt {
   fn export_environment_variables<'a>(
     &mut self,
     scope: &BTreeMap<&'a str, String>,

src/common.rs

@@ -49,9 +49,9 @@ pub(crate) use crate::{
   verbosity::Verbosity,
 };
 
-pub type CompilationResult<'a, T> = Result<T, CompilationError<'a>>;
+pub(crate) type CompilationResult<'a, T> = Result<T, CompilationError<'a>>;
 
-pub type RunResult<'a, T> = Result<T, RuntimeError<'a>>;
+pub(crate) type RunResult<'a, T> = Result<T, RuntimeError<'a>>;
 
 #[allow(unused_imports)]
 pub(crate) use std::io::prelude::*;

src/compilation_error.rs

@@ -3,13 +3,13 @@ use crate::common::*;
 use crate::misc::{maybe_s, show_whitespace, write_error_context, Or};
 
 #[derive(Debug, PartialEq)]
-pub struct CompilationError<'a> {
-  pub text: &'a str,
-  pub offset: usize,
-  pub line: usize,
-  pub column: usize,
-  pub width: usize,
-  pub kind: CompilationErrorKind<'a>,
+pub(crate) struct CompilationError<'a> {
+  pub(crate) text: &'a str,
+  pub(crate) offset: usize,
+  pub(crate) line: usize,
+  pub(crate) column: usize,
+  pub(crate) width: usize,
+  pub(crate) kind: CompilationErrorKind<'a>,
 }
 
 impl<'a> Display for CompilationError<'a> {

src/compilation_error_kind.rs

@@ -1,7 +1,7 @@
 use crate::common::*;
 
 #[derive(Debug, PartialEq)]
-pub enum CompilationErrorKind<'a> {
+pub(crate) enum CompilationErrorKind<'a> {
   AliasShadowsRecipe {
     alias: &'a str,
     recipe_line: usize,

src/configuration.rs

@@ -1,16 +1,16 @@
 use crate::common::*;
 
-pub const DEFAULT_SHELL: &str = "sh";
+pub(crate) const DEFAULT_SHELL: &str = "sh";
 
-pub struct Configuration<'a> {
-  pub dry_run: bool,
-  pub evaluate: bool,
-  pub highlight: bool,
-  pub overrides: BTreeMap<&'a str, &'a str>,
-  pub quiet: bool,
-  pub shell: &'a str,
-  pub color: Color,
-  pub verbosity: Verbosity,
+pub(crate) struct Configuration<'a> {
+  pub(crate) dry_run: bool,
+  pub(crate) evaluate: bool,
+  pub(crate) highlight: bool,
+  pub(crate) overrides: BTreeMap<&'a str, &'a str>,
+  pub(crate) quiet: bool,
+  pub(crate) shell: &'a str,
+  pub(crate) color: Color,
+  pub(crate) verbosity: Verbosity,
 }
 
 impl<'a> Default for Configuration<'a> {

src/expression.rs

@@ -1,7 +1,7 @@
 use crate::common::*;
 
 #[derive(PartialEq, Debug)]
-pub enum Expression<'a> {
+pub(crate) enum Expression<'a> {
   Backtick {
     raw: &'a str,
     token: Token<'a>,
@@ -28,11 +28,11 @@ pub enum Expression<'a> {
 }
 
 impl<'a> Expression<'a> {
-  pub fn variables(&'a self) -> Variables<'a> {
+  pub(crate) fn variables(&'a self) -> Variables<'a> {
     Variables::new(self)
   }
 
-  pub fn functions(&'a self) -> Functions<'a> {
+  pub(crate) fn functions(&'a self) -> Functions<'a> {
     Functions::new(self)
   }
 }

src/fragment.rs

@@ -1,13 +1,13 @@
 use crate::common::*;
 
 #[derive(PartialEq, Debug)]
-pub enum Fragment<'a> {
+pub(crate) enum Fragment<'a> {
   Text { text: Token<'a> },
   Expression { expression: Expression<'a> },
 }
 
 impl<'a> Fragment<'a> {
-  pub fn continuation(&self) -> bool {
+  pub(crate) fn continuation(&self) -> bool {
     match *self {
       Fragment::Text { ref text } => text.lexeme().ends_with('\\'),
       _ => false,