just/src/lib.rs

#[cfg(test)]
mod unit;

#[cfg(test)]
mod integration;

mod app;

pub use app::app;

#[macro_use]
extern crate lazy_static;
extern crate regex;
extern crate tempdir;
extern crate itertools;
extern crate ansi_term;
extern crate unicode_width;
extern crate edit_distance;

use std::io::prelude::*;

use std::{fs, fmt, process, io, cmp};
use std::ops::Range;
use std::fmt::Display;
use regex::Regex;
use std::collections::{BTreeMap as Map, BTreeSet as Set};

use std::os::unix::fs::PermissionsExt;

macro_rules! warn {
  ($($arg:tt)*) => {{
    extern crate std;
    use std::io::prelude::*;
    let _ = writeln!(&mut std::io::stderr(), $($arg)*);
  }};
}

macro_rules! die {
  ($($arg:tt)*) => {{
    extern crate std;
    warn!($($arg)*);
    std::process::exit(-1)
  }};
}

trait Slurp {
  fn slurp(&mut self) -> Result<String, std::io::Error>;
}

impl Slurp for fs::File {
  fn slurp(&mut self) -> Result<String, std::io::Error> {
    let mut destination = String::new();
    self.read_to_string(&mut destination)?;
    Ok(destination)
  }
}

fn re(pattern: &str) -> Regex {
  Regex::new(pattern).unwrap()
}

fn contains<T: PartialOrd>(range: &Range<T>,  i: T) -> bool {
  i >= range.start && i < range.end
}

#[derive(PartialEq, Debug)]
struct Recipe<'a> {
  line_number:       usize,
  name:              &'a str,
  lines:             Vec<Vec<Fragment<'a>>>,
  dependencies:      Vec<&'a str>,
  dependency_tokens: Vec<Token<'a>>,
  parameters:        Vec<Parameter<'a>>,
  shebang:           bool,
}

#[derive(PartialEq, Debug)]
struct Parameter<'a> {
  name:    &'a str,
  default: Option<String>,
  token:   Token<'a>,
}

impl<'a> Display for Parameter<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    write!(f, "{}", self.name)?;
    if let Some(ref default) = self.default {
      let escaped = default.chars().flat_map(char::escape_default).collect::<String>();;
      write!(f, r#"='{}'"#, escaped)?;
    }
    Ok(())
  }
}

#[derive(PartialEq, Debug)]
enum Fragment<'a> {
  Text{text: Token<'a>},
  Expression{expression: Expression<'a>},
}

#[derive(PartialEq, Debug)]
enum Expression<'a> {
  Variable{name: &'a str, token: Token<'a>},
  String{cooked_string: CookedString<'a>},
  Backtick{raw: &'a str, token: Token<'a>},
  Concatination{lhs: Box<Expression<'a>>, rhs: Box<Expression<'a>>},
}

impl<'a> Expression<'a> {
  fn variables(&'a self) -> Variables<'a> {
    Variables {
      stack: vec![self],
    }
  }
}

struct Variables<'a> {
  stack: Vec<&'a Expression<'a>>,
}

impl<'a> Iterator for Variables<'a> {
  type Item = &'a Token<'a>;

  fn next(&mut self) -> Option<&'a Token<'a>> {
    match self.stack.pop() {
      None | Some(&Expression::String{..}) | Some(&Expression::Backtick{..}) => None,
      Some(&Expression::Variable{ref token,..})          => Some(token),
      Some(&Expression::Concatination{ref lhs, ref rhs}) => {
        self.stack.push(lhs);
        self.stack.push(rhs);
        self.next()
      }
    }
  }
}

impl<'a> Display for Expression<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    match *self {
      Expression::Backtick     {raw, ..          } => write!(f, "`{}`", raw)?,
      Expression::Concatination{ref lhs, ref rhs } => write!(f, "{} + {}", lhs, rhs)?,
      Expression::String       {ref cooked_string} => write!(f, "\"{}\"", cooked_string.raw)?,
      Expression::Variable     {name, ..         } => write!(f, "{}", name)?,
    }
    Ok(())
  }
}

#[cfg(unix)]
fn error_from_signal(recipe: &str, exit_status: process::ExitStatus) -> RunError {
  use std::os::unix::process::ExitStatusExt;
  match exit_status.signal() {
    Some(signal) => RunError::Signal{recipe: recipe, signal: signal},
    None => RunError::UnknownFailure{recipe: recipe},
  }
}

#[cfg(windows)]
fn error_from_signal(recipe: &str, exit_status: process::ExitStatus) -> RunError {
  RunError::UnknownFailure{recipe: recipe}
}

#[cfg(unix)]
fn backtick_error_from_signal<'a>(
  token:       &Token<'a>,
  exit_status: process::ExitStatus
) -> RunError<'a> {
  use std::os::unix::process::ExitStatusExt;
  match exit_status.signal() {
    Some(signal) => RunError::BacktickSignal{token: token.clone(), signal: signal},
    None => RunError::BacktickUnknownFailure{token: token.clone()},
  }
}

#[cfg(windows)]
fn backtick_error_from_signal<'a>(
  token:       &Token<'a>,
  exit_status: process::ExitStatus
) -> RunError<'a> {
  RunError::BacktickUnknownFailure{token: token.clone()}
}

fn export_env<'a>(
  command: &mut process::Command,
  scope:   &Map<&'a str, String>,
  exports: &Set<&'a str>,
) -> Result<(), RunError<'a>> {
  for name in exports {
    if let Some(value) = scope.get(name) {
      command.env(name, value);
    } else {
      return Err(RunError::InternalError {
        message: format!("scope does not contain exported variable `{}`",  name),
      });
    }
  }
  Ok(())
}


fn run_backtick<'a>(
  raw:     &str,
  token:   &Token<'a>,
  scope:   &Map<&'a str, String>,
  exports: &Set<&'a str>,
  quiet:   bool,
) -> Result<String, RunError<'a>> {
  let mut cmd = process::Command::new("sh");

  export_env(&mut cmd, scope, exports)?;

  cmd.arg("-cu")
     .arg(raw);

  cmd.stderr(if quiet {
    process::Stdio::null()
  } else {
    process::Stdio::inherit()
  });

  match cmd.output() {
    Ok(output) => {
      if let Some(code) = output.status.code() {
        if code != 0 {
          return Err(RunError::BacktickCode {
            token: token.clone(),
            code: code,
          });
        }
      } else {
        return Err(backtick_error_from_signal(token, output.status));
      }
      match std::str::from_utf8(&output.stdout) {
        Err(error) => Err(RunError::BacktickUtf8Error{token: token.clone(), utf8_error: error}),
        Ok(utf8) => {
          Ok(if utf8.ends_with('\n') {
            &utf8[0..utf8.len()-1]
          } else if utf8.ends_with("\r\n") {
            &utf8[0..utf8.len()-2]
          } else {
            utf8
          }.to_string())
        }
      }
    }
    Err(error) => Err(RunError::BacktickIoError{token: token.clone(), io_error: error}),
  }
}

impl<'a> Recipe<'a> {
  fn argument_range(&self) -> Range<usize> {
    self.parameters.iter().filter(|p| !p.default.is_some()).count()
      ..
    self.parameters.len() + 1
  }

  fn run(
    &self,
    arguments: &[&'a str],
    scope:     &Map<&'a str, String>,
    exports:   &Set<&'a str>,
    options:   &RunOptions,
  ) -> Result<(), RunError<'a>> {
    let argument_map = self.parameters.iter().enumerate()
      .map(|(i, parameter)| if i < arguments.len() {
        (parameter.name, arguments[i])
      } else if let Some(ref default) = parameter.default {
        (parameter.name, default.as_str())
      } else {
        panic!("Recipe.run: missing parameter without default. This is a bug in just.");
      }).collect();

    let mut evaluator = Evaluator {
      evaluated:   Map::new(),
      scope:       scope,
      exports:     exports,
      assignments: &Map::new(),
      overrides:   &Map::new(),
      quiet:       options.quiet,
    };

    if self.shebang {
      let mut evaluated_lines = vec![];
      for line in &self.lines {
        evaluated_lines.push(evaluator.evaluate_line(line, &argument_map)?);
      }

      if options.dry_run {
        for line in evaluated_lines {
          warn!("{}", line);
        }
        return Ok(());
      }

      let tmp = tempdir::TempDir::new("just")
        .map_err(|error| RunError::TmpdirIoError{recipe: self.name, io_error: error})?;
      let mut path = tmp.path().to_path_buf();
      path.push(self.name);
      {
        let mut f = fs::File::create(&path)
          .map_err(|error| RunError::TmpdirIoError{recipe: self.name, io_error: error})?;
        let mut text = String::new();
        // add the shebang
        text += &evaluated_lines[0];
        text += "\n";
        // add blank lines so that lines in the generated script
        // have the same line number as the corresponding lines
        // in the justfile
        for _ in 1..(self.line_number + 2) {
          text += "\n"
        }
        for line in &evaluated_lines[1..] {
          text += line;
          text += "\n";
        }
        f.write_all(text.as_bytes())
         .map_err(|error| RunError::TmpdirIoError{recipe: self.name, io_error: error})?;
      }

      // get current permissions
      let mut perms = fs::metadata(&path)
        .map_err(|error| RunError::TmpdirIoError{recipe: self.name, io_error: error})?
        .permissions();

      // make the script executable
      let current_mode = perms.mode();
      perms.set_mode(current_mode | 0o100);
      fs::set_permissions(&path, perms)
        .map_err(|error| RunError::TmpdirIoError{recipe: self.name, io_error: error})?;

      // run it!
      let mut command = process::Command::new(path);

      export_env(&mut command, scope, exports)?;

      match command.status() {
        Ok(exit_status) => if let Some(code) = exit_status.code() {
          if code != 0 {
            return Err(RunError::Code{recipe: self.name, code: code})
          }
        } else {
          return Err(error_from_signal(self.name, exit_status))
        },
        Err(io_error) => return Err(RunError::TmpdirIoError{
          recipe: self.name, io_error: io_error})
      };
    } else {
      for line in &self.lines {
        let evaluated = &evaluator.evaluate_line(line, &argument_map)?;
        let mut command = evaluated.as_str();
        let quiet_command = command.starts_with('@');
        if quiet_command {
          command = &command[1..];
        }
        if options.dry_run || !(quiet_command || options.quiet) {
          warn!("{}", command);
        }
        if options.dry_run {
          continue;
        }

        let mut cmd = process::Command::new("sh");

        cmd.arg("-cu").arg(command);

        if options.quiet {
          cmd.stderr(process::Stdio::null());
          cmd.stdout(process::Stdio::null());
        }

        export_env(&mut cmd, scope, exports)?;

        match cmd.status() {
          Ok(exit_status) => if let Some(code) = exit_status.code() {
            if code != 0 {
              return Err(RunError::Code{recipe: self.name, code: code});
            }
          } else {
            return Err(error_from_signal(self.name, exit_status));
          },
          Err(io_error) => return Err(RunError::IoError{
            recipe: self.name, io_error: io_error}),
        };
      }
    }
    Ok(())
  }
}

impl<'a> Display for Recipe<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    write!(f, "{}", self.name)?;
    for parameter in &self.parameters {
      write!(f, " {}", parameter)?;
    }
    write!(f, ":")?;
    for dependency in &self.dependencies {
      write!(f, " {}", dependency)?;
    }

    for (i, pieces) in self.lines.iter().enumerate() {
      if i == 0 {
        writeln!(f, "")?;
      }
      for (j, piece) in pieces.iter().enumerate() {
        if j == 0 {
          write!(f, "    ")?;
        }
        match *piece {
          Fragment::Text{ref text} => write!(f, "{}", text.lexeme)?,
          Fragment::Expression{ref expression, ..} => 
            write!(f, "{}{}{}", "{{", expression, "}}")?,
        }
      }
      if i + 1 < self.lines.len() {
        write!(f, "\n")?;
      }
    }
    Ok(())
  }
}

fn resolve_recipes<'a>(
  recipes:     &Map<&'a str, Recipe<'a>>,
  assignments: &Map<&'a str, Expression<'a>>,
  text:        &'a str,
) -> Result<(), Error<'a>> {
  let mut resolver = Resolver {
    seen:              Set::new(),
    stack:             vec![],
    resolved:          Set::new(),
    recipes:           recipes,
  };
  
  for recipe in recipes.values() {
    resolver.resolve(recipe)?;
  }

  for recipe in recipes.values() {
    for line in &recipe.lines {
      for fragment in line {
        if let Fragment::Expression{ref expression, ..} = *fragment {
          for variable in expression.variables() {
            let name = variable.lexeme;
            let undefined = !assignments.contains_key(name) 
              && !recipe.parameters.iter().any(|p| p.name == name);
            if undefined {
              // There's a borrow issue here that seems too difficult to solve.
              // The error derived from the variable token has too short a lifetime,
              // so we create a new error from its contents, which do live long
              // enough.
              //
              // I suspect the solution here is to give recipes, pieces, and expressions
              // two lifetime parameters instead of one, with one being the lifetime
              // of the struct, and the second being the lifetime of the tokens
              // that it contains
              let error = variable.error(ErrorKind::UndefinedVariable{variable: name});
              return Err(Error {
                text:   text,
                index:  error.index,
                line:   error.line,
                column: error.column,
                width:  error.width,
                kind:   ErrorKind::UndefinedVariable {
                  variable: &text[error.index..error.index + error.width.unwrap()],
                }
              });
            }
          }
        }
      }
    }
  }

  Ok(())
}

struct Resolver<'a: 'b, 'b> {
  stack:    Vec<&'a str>,
  seen:     Set<&'a str>,
  resolved: Set<&'a str>,
  recipes:  &'b Map<&'a str, Recipe<'a>>,
}

impl<'a, 'b> Resolver<'a, 'b> {
  fn resolve(&mut self, recipe: &Recipe<'a>) -> Result<(), Error<'a>> {
    if self.resolved.contains(recipe.name) {
      return Ok(())
    }
    self.stack.push(recipe.name);
    self.seen.insert(recipe.name);
    for dependency_token in &recipe.dependency_tokens {
      match self.recipes.get(dependency_token.lexeme) {
        Some(dependency) => if !self.resolved.contains(dependency.name) {
          if self.seen.contains(dependency.name) {
            let first = self.stack[0];
            self.stack.push(first);
            return Err(dependency_token.error(ErrorKind::CircularRecipeDependency {
              recipe: recipe.name,
              circle: self.stack.iter()
                .skip_while(|name| **name != dependency.name)
                .cloned().collect()
            }));
          }
          return self.resolve(dependency);
        },
        None => return Err(dependency_token.error(ErrorKind::UnknownDependency {
          recipe:  recipe.name,
          unknown: dependency_token.lexeme
        })),
      }
    }
    self.resolved.insert(recipe.name);
    self.stack.pop();
    Ok(())
  }
}

fn resolve_assignments<'a>(
  assignments:       &Map<&'a str, Expression<'a>>,
  assignment_tokens: &Map<&'a str, Token<'a>>,
) -> Result<(), Error<'a>> {

  let mut resolver = AssignmentResolver {
    assignments:       assignments,
    assignment_tokens: assignment_tokens,
    stack:             vec![],
    seen:              Set::new(),
    evaluated:         Set::new(),
  };

  for name in assignments.keys() {
    resolver.resolve_assignment(name)?;
  }

  Ok(())
}

struct AssignmentResolver<'a: 'b, 'b> {
  assignments:       &'b Map<&'a str, Expression<'a>>,
  assignment_tokens: &'b Map<&'a str, Token<'a>>,
  stack:             Vec<&'a str>,
  seen:              Set<&'a str>,
  evaluated:         Set<&'a str>,
}

impl<'a: 'b, 'b> AssignmentResolver<'a, 'b> {
  fn resolve_assignment(&mut self, name: &'a str) -> Result<(), Error<'a>> {
    if self.evaluated.contains(name) {
      return Ok(());
    }

    self.seen.insert(name);
    self.stack.push(name);

    if let Some(expression) = self.assignments.get(name) {
      self.resolve_expression(expression)?;
      self.evaluated.insert(name);
    } else {
      return Err(internal_error(format!("attempted to resolve unknown assignment `{}`", name)));
    }
    Ok(())
  }

  fn resolve_expression(&mut self, expression: &Expression<'a>) -> Result<(), Error<'a>> {
    match *expression {
      Expression::Variable{name, ref token} => {
        if self.evaluated.contains(name) {
          return Ok(());
        } else if self.seen.contains(name) {
          let token = &self.assignment_tokens[name];
          self.stack.push(name);
          return Err(token.error(ErrorKind::CircularVariableDependency {
            variable: name,
            circle:   self.stack.clone(),
          }));
        } else if self.assignments.contains_key(name) {
          self.resolve_assignment(name)?;
        } else {
          return Err(token.error(ErrorKind::UndefinedVariable{variable: name}));
        }
      }
      Expression::Concatination{ref lhs, ref rhs} => {
        self.resolve_expression(lhs)?;
        self.resolve_expression(rhs)?;
      }
      Expression::String{..} | Expression::Backtick{..} => {}
    }
    Ok(())
  }
}

fn evaluate_assignments<'a>(
  assignments: &Map<&'a str, Expression<'a>>,
  overrides:   &Map<&str, &str>,
  quiet:       bool,
) -> Result<Map<&'a str, String>, RunError<'a>> {
  let mut evaluator = Evaluator {
    assignments: assignments,
    evaluated:   Map::new(),
    exports:     &Set::new(),
    overrides:   overrides,
    quiet:       quiet,
    scope:       &Map::new(),
  };

  for name in assignments.keys() {
    evaluator.evaluate_assignment(name)?;
  }

  Ok(evaluator.evaluated)
}

struct Evaluator<'a: 'b, 'b> {
  assignments: &'b Map<&'a str, Expression<'a>>,
  evaluated:   Map<&'a str, String>,
  exports:     &'b Set<&'a str>,
  overrides:   &'b Map<&'b str, &'b str>,
  quiet:       bool,
  scope:       &'b Map<&'a str, String>,
}

impl<'a, 'b> Evaluator<'a, 'b> {
  fn evaluate_line(
    &mut self,
    line:      &[Fragment<'a>],
    arguments: &Map<&str, &str>
  ) -> Result<String, RunError<'a>> {
    let mut evaluated = String::new();
    for fragment in line {
      match *fragment {
        Fragment::Text{ref text} => evaluated += text.lexeme,
        Fragment::Expression{ref expression} => {
          evaluated += &self.evaluate_expression(expression, arguments)?;
        }
      }
    }
    Ok(evaluated)
  }

  fn evaluate_assignment(&mut self, name: &'a str) -> Result<(), RunError<'a>> {
    if self.evaluated.contains_key(name) {
      return Ok(());
    }

    if let Some(expression) = self.assignments.get(name) {
      if let Some(value) = self.overrides.get(name) {
        self.evaluated.insert(name, value.to_string());
      } else {
        let value = self.evaluate_expression(expression, &Map::new())?;
        self.evaluated.insert(name, value);
      }
    } else {
      return Err(RunError::InternalError { 
        message: format!("attempted to evaluated unknown assignment {}", name)
      });
    }

    Ok(())
  }

  fn evaluate_expression(
    &mut self,
    expression: &Expression<'a>,
    arguments: &Map<&str, &str>
  ) -> Result<String, RunError<'a>> {
    Ok(match *expression {
      Expression::Variable{name, ..} => {
        if self.evaluated.contains_key(name) {
          self.evaluated[name].clone()
        } else if self.scope.contains_key(name) {
          self.scope[name].clone()
        } else if self.assignments.contains_key(name) {
          self.evaluate_assignment(name)?;
          self.evaluated[name].clone()
        } else if arguments.contains_key(name) {
          arguments[name].to_string()
        } else {
          return Err(RunError::InternalError { 
            message: format!("attempted to evaluate undefined variable `{}`", name)
          });
        }
      }
      Expression::String{ref cooked_string} => cooked_string.cooked.clone(),
      Expression::Backtick{raw, ref token} => {
        run_backtick(raw, token, self.scope, self.exports, self.quiet)?
      }
      Expression::Concatination{ref lhs, ref rhs} => {
        self.evaluate_expression(lhs, arguments)?
          +
        &self.evaluate_expression(rhs, arguments)?
      }
    })
  }
}

#[derive(Debug, PartialEq)]
struct Error<'a> {
  text:   &'a str,
  index:  usize,
  line:   usize,
  column: usize,
  width:  Option<usize>,
  kind:   ErrorKind<'a>,
}

#[derive(Debug, PartialEq)]
enum ErrorKind<'a> {
  CircularRecipeDependency{recipe: &'a str, circle: Vec<&'a str>},
  CircularVariableDependency{variable: &'a str, circle: Vec<&'a str>},
  DependencyHasParameters{recipe: &'a str, dependency: &'a str},
  DuplicateDependency{recipe: &'a str, dependency: &'a str},
  DuplicateParameter{recipe: &'a str, parameter: &'a str},
  DuplicateRecipe{recipe: &'a str, first: usize},
  DuplicateVariable{variable: &'a str},
  ExtraLeadingWhitespace,
  InconsistentLeadingWhitespace{expected: &'a str, found: &'a str},
  InternalError{message: String},
  InvalidEscapeSequence{character: char},
  MixedLeadingWhitespace{whitespace: &'a str},
  OuterShebang,
  ParameterShadowsVariable{parameter: &'a str},
  RequiredParameterFollowsDefaultParameter{parameter: &'a str},
  UndefinedVariable{variable: &'a str},
  UnexpectedToken{expected: Vec<TokenKind>, found: TokenKind},
  UnknownDependency{recipe: &'a str, unknown: &'a str},
  UnknownStartOfToken,
  UnterminatedString,
}

fn internal_error(message: String) -> Error<'static> {
  Error {
    text:   "",
    index:  0,
    line:   0,
    column: 0,
    width:  None,
    kind:   ErrorKind::InternalError { message: message }
  }
}

fn show_whitespace(text: &str) -> String {
  text.chars().map(|c| match c { '\t' => 't', ' ' => 's', _ => c }).collect()
}

fn mixed_whitespace(text: &str) -> bool {
  !(text.chars().all(|c| c == ' ') || text.chars().all(|c| c == '\t'))
}

fn maybe_s(n: usize) -> &'static str {
  if n == 1 {
    ""
  } else {
    "s"
  }
}

struct Tick<'a, T: 'a + Display>(&'a T);

impl<'a, T: Display> Display for Tick<'a, T> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    write!(f, "`{}`", self.0)
  }
}

fn ticks<T: Display>(ts: &[T]) -> Vec<Tick<T>> {
  ts.iter().map(Tick).collect()
}

#[derive(PartialEq, Debug)]
struct CookedString<'a> {
  raw:    &'a str,
  cooked: String,
}

fn cook_string<'a>(token: &Token<'a>) -> Result<CookedString<'a>, Error<'a>> {
  let raw = &token.lexeme[1..token.lexeme.len()-1];

  if let RawString = token.kind {
    Ok(CookedString{raw: raw, cooked: raw.to_string()})
  } else if let StringToken = token.kind {
    let mut cooked = String::new();
    let mut escape = false;
    for c in raw.chars() {
      if escape {
        match c {
          'n'   => cooked.push('\n'),
          'r'   => cooked.push('\r'),
          't'   => cooked.push('\t'),
          '\\'  => cooked.push('\\'),
          '"'   => cooked.push('"'),
          other => return Err(token.error(ErrorKind::InvalidEscapeSequence {
            character: other,
          })),
        }
        escape = false;
        continue;
      }
      if c == '\\' {
        escape = true;
        continue;
      }
      cooked.push(c);
    }
    Ok(CookedString{raw: raw, cooked: cooked})
  } else {
    Err(token.error(ErrorKind::InternalError{
      message: "cook_string() called on non-string token".to_string()
    }))
  }
}

struct And<'a, T: 'a + Display>(&'a [T]);
struct Or <'a, T: 'a + Display>(&'a [T]);

impl<'a, T: Display> Display for And<'a, T> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    conjoin(f, self.0, "and")
  }
}

impl<'a, T: Display> Display for Or<'a, T> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    conjoin(f, self.0, "or")
  }
}

fn conjoin<T: Display>(
  f:           &mut fmt::Formatter,
  values:      &[T],
  conjunction: &str,
) -> Result<(), fmt::Error> {
    match values.len() {
      0 => {},
      1 => write!(f, "{}", values[0])?,
      2 => write!(f, "{} {} {}", values[0], conjunction, values[1])?,
      _ => for (i, item) in values.iter().enumerate() {
        write!(f, "{}", item)?;
        if i == values.len() - 1 {
        } else if i == values.len() - 2 {
          write!(f, ", {} ", conjunction)?;
        } else {
          write!(f, ", ")?
        }
      },
    }
    Ok(())
}

fn write_error_context(
  f:      &mut fmt::Formatter,
  text:   &str,
  index:  usize,
  line:   usize,
  column: usize,
  width:  Option<usize>,
) -> Result<(), fmt::Error> {
  let line_number = line + 1;
  let red = maybe_red(f.alternate());
  match text.lines().nth(line) {
    Some(line) => {
      let mut i = 0;
      let mut space_column = 0;
      let mut space_line   = String::new();
      let mut space_width  = 0;
      for c in line.chars() {
        if c == '\t' {
          space_line.push_str("    ");
          if i < column {
            space_column += 4;
          }
          if i >= column && i < column + width.unwrap_or(1) {
            space_width += 4;
          }
        } else {
          if i < column {
            space_column += unicode_width::UnicodeWidthChar::width(c).unwrap_or(0);

          }
          if i >= column && i < column + width.unwrap_or(1) {
            space_width += unicode_width::UnicodeWidthChar::width(c).unwrap_or(0);
          }
          space_line.push(c);
        }
        i += c.len_utf8();
      }
      let line_number_width = line_number.to_string().len();
      write!(f, "{0:1$} |\n", "", line_number_width)?;
      write!(f, "{} | {}\n", line_number, space_line)?;
      write!(f, "{0:1$} |", "", line_number_width)?;
      if width == None {
        write!(f, " {0:1$}{2}^{3}", "", space_column, red.prefix(), red.suffix())?;
      } else {
        write!(f, " {0:1$}{2}{3:^<4$}{5}", "", space_column,
                  red.prefix(), "", space_width, red.suffix())?;
      }
    },
    None => if index != text.len() {
      write!(f, "internal error: Error has invalid line number: {}", line_number)?
    },
  }
  Ok(())
}

fn write_token_error_context(f: &mut fmt::Formatter, token: &Token) -> Result<(), fmt::Error> {
  write_error_context(
    f,
    token.text,
    token.index,
    token.line,
    token.column + token.prefix.len(),
    Some(token.lexeme.len())
  )
}

fn maybe_red(colors: bool) -> ansi_term::Style {
  if colors {
    ansi_term::Style::new().fg(ansi_term::Color::Red).bold()
  } else {
    ansi_term::Style::default()
  }
}

fn maybe_bold(colors: bool) -> ansi_term::Style {
  if colors {
    ansi_term::Style::new().bold()
  } else {
    ansi_term::Style::default()
  }
}

impl<'a> Display for Error<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    let red  = maybe_red(f.alternate());
    let bold = maybe_bold(f.alternate());

    write!(f, "{} {}", red.paint("error:"), bold.prefix())?;
    
    match self.kind {
      ErrorKind::CircularRecipeDependency{recipe, ref circle} => {
        if circle.len() == 2 {
          write!(f, "recipe `{}` depends on itself", recipe)?;
        } else {
          writeln!(f, "recipe `{}` has circular dependency `{}`",
                      recipe, circle.join(" -> "))?;
        }
      }
      ErrorKind::CircularVariableDependency{variable, ref circle} => {
        if circle.len() == 2 {
          writeln!(f, "variable `{}` depends on its own value: `{}`",
                      variable, circle.join(" -> "))?;
        } else {
          writeln!(f, "variable `{}` depends on its own value: `{}`",
                      variable, circle.join(" -> "))?;
        }
      }
      ErrorKind::InvalidEscapeSequence{character} => {
        writeln!(f, "`\\{}` is not a valid escape sequence",
                    character.escape_default().collect::<String>())?;
      }
      ErrorKind::DuplicateParameter{recipe, parameter} => {
        writeln!(f, "recipe `{}` has duplicate parameter `{}`", recipe, parameter)?;
      }
      ErrorKind::DuplicateVariable{variable} => {
        writeln!(f, "variable `{}` is has multiple definitions", variable)?;
      }
      ErrorKind::UnexpectedToken{ref expected, found} => {
        writeln!(f, "expected {} but found {}", Or(expected), found)?;
      }
      ErrorKind::DuplicateDependency{recipe, dependency} => {
        writeln!(f, "recipe `{}` has duplicate dependency `{}`", recipe, dependency)?;
      }
      ErrorKind::DuplicateRecipe{recipe, first} => {
        writeln!(f, "recipe `{}` first defined on line {} is redefined on line {}",
                    recipe, first, self.line)?;
      }
      ErrorKind::DependencyHasParameters{recipe, dependency} => {
        writeln!(f, "recipe `{}` depends on `{}` which requires arguments. \
                    dependencies may not require arguments", recipe, dependency)?;
      }
      ErrorKind::ParameterShadowsVariable{parameter} => {
        writeln!(f, "parameter `{}` shadows variable of the same name", parameter)?;
      }
      ErrorKind::RequiredParameterFollowsDefaultParameter{parameter} => {
        writeln!(f, "non-default parameter `{}` follows default parameter", parameter)?;
      }
      ErrorKind::MixedLeadingWhitespace{whitespace} => {
        writeln!(f,
          "found a mix of tabs and spaces in leading whitespace: `{}`\n\
          leading whitespace may consist of tabs or spaces, but not both",
          show_whitespace(whitespace)
        )?;
      }
      ErrorKind::ExtraLeadingWhitespace => {
        writeln!(f, "recipe line has extra leading whitespace")?;
      }
      ErrorKind::InconsistentLeadingWhitespace{expected, found} => {
        writeln!(f,
          "inconsistant leading whitespace: recipe started with `{}` but found line with `{}`:",
          show_whitespace(expected), show_whitespace(found)
        )?;
      }
      ErrorKind::OuterShebang => {
        writeln!(f, "a shebang `#!` is reserved syntax outside of recipes")?;
      }
      ErrorKind::UnknownDependency{recipe, unknown} => {
        writeln!(f, "recipe `{}` has unknown dependency `{}`", recipe, unknown)?;
      }
      ErrorKind::UndefinedVariable{variable} => {
        writeln!(f, "variable `{}` not defined", variable)?;
      }
      ErrorKind::UnknownStartOfToken => {
        writeln!(f, "unknown start of token:")?;
      }
      ErrorKind::UnterminatedString => {
        writeln!(f, "unterminated string")?;
      }
      ErrorKind::InternalError{ref message} => {
        writeln!(f, "internal error, this may indicate a bug in just: {}\n\
                     consider filing an issue: https://github.com/casey/just/issues/new",
                     message)?;
      }
    }

    write!(f, "{}", bold.suffix())?;

    write_error_context(f, self.text, self.index, self.line, self.column, self.width)
  }
}

struct Justfile<'a> {
  recipes:     Map<&'a str, Recipe<'a>>,
  assignments: Map<&'a str, Expression<'a>>,
  exports:     Set<&'a str>,
}

#[derive(Default)]
struct RunOptions<'a> {
  dry_run:   bool,
  evaluate:  bool,
  overrides: Map<&'a str, &'a str>,
  quiet:     bool,
}

impl<'a, 'b> Justfile<'a> where 'a: 'b {
  fn first(&self) -> Option<&'a str> {
    let mut first: Option<&Recipe<'a>> = None;
    for recipe in self.recipes.values() {
      if let Some(first_recipe) = first {
        if recipe.line_number < first_recipe.line_number {
          first = Some(recipe)
        }
      } else {
        first = Some(recipe);
      }
    }
    first.map(|recipe| recipe.name)
  }

  fn count(&self) -> usize {
    self.recipes.len()
  }

  fn recipes(&self) -> Vec<&'a str> {
    self.recipes.keys().cloned().collect()
  }

  fn suggest(&self, name: &str) -> Option<&'a str> {
    let mut suggestions = self.recipes.keys()
      .map(|suggestion| (edit_distance::edit_distance(suggestion, name), suggestion))
      .collect::<Vec<_>>();
    suggestions.sort();
    if let Some(&(distance, suggestion)) = suggestions.first() {
      if distance < 3 {
        return Some(suggestion)
      }
    }
    None
  }

  fn run(
    &'a self,
    arguments: &[&'a str],
    options:   &RunOptions<'a>,
  ) -> Result<(), RunError<'a>> {
    let unknown_overrides = options.overrides.keys().cloned()
      .filter(|name| !self.assignments.contains_key(name))
      .collect::<Vec<_>>();

    if !unknown_overrides.is_empty() {
      return Err(RunError::UnknownOverrides{overrides: unknown_overrides});
    }

    let scope = evaluate_assignments(&self.assignments, &options.overrides, options.quiet)?;
    if options.evaluate {
      let mut width = 0;
      for name in scope.keys() {
        width = cmp::max(name.len(), width);
      }

      for (name, value) in scope {
        println!("{0:1$} = \"{2}\"", name, width, value);
      }
      return Ok(());
    }

    let mut ran = Set::new();

    for (i, argument) in arguments.iter().enumerate() {
      if let Some(recipe) = self.recipes.get(argument) {
        if !recipe.parameters.is_empty() {
          if i != 0 {
            return Err(RunError::NonLeadingRecipeWithParameters{recipe: recipe.name});
          }
          let rest = &arguments[1..];
          let argument_range = recipe.argument_range();
          if !contains(&argument_range, rest.len()) {
            return Err(RunError::ArgumentCountMismatch {
              recipe: recipe.name,
              found:  rest.len(),
              min:    argument_range.start,
              max:    argument_range.end - 1,
            });
          }
          return self.run_recipe(recipe, rest, &scope, &mut ran, options);
        }
      } else {
        break;
      }
    }

    let mut missing = vec![];
    for recipe in arguments {
      if !self.recipes.contains_key(recipe) {
        missing.push(*recipe);
      }
    }
    if !missing.is_empty() {
      let suggestion = if missing.len() == 1 {
        self.suggest(missing.first().unwrap())
      } else {
        None
      };
      return Err(RunError::UnknownRecipes{recipes: missing, suggestion: suggestion});
    }
    for recipe in arguments.iter().map(|name| &self.recipes[name]) {
      self.run_recipe(recipe, &[], &scope, &mut ran, options)?;
    }
    Ok(())
  }

  fn run_recipe<'c>(
    &'c self,
    recipe:    &Recipe<'a>,
    arguments: &[&'a str],
    scope:     &Map<&'c str, String>,
    ran:       &mut Set<&'a str>,
    options:   &RunOptions<'a>,
  ) -> Result<(), RunError> {
    for dependency_name in &recipe.dependencies {
      if !ran.contains(dependency_name) {
        self.run_recipe(&self.recipes[dependency_name], &[], scope, ran, options)?;
      }
    }
    recipe.run(arguments, scope, &self.exports, options)?;
    ran.insert(recipe.name);
    Ok(())
  }
}

impl<'a> Display for Justfile<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    let mut items = self.recipes.len() + self.assignments.len();
    for (name, expression) in &self.assignments {
      if self.exports.contains(name) {
        write!(f, "export ")?;
      }
      write!(f, "{} = {}", name, expression)?;
      items -= 1;
      if items != 0 {
        write!(f, "\n\n")?;
      }
    }
    for recipe in self.recipes.values() {
      write!(f, "{}", recipe)?;
      items -= 1;
      if items != 0 {
        write!(f, "\n\n")?;
      }
    }
    Ok(())
  }
}

#[derive(Debug)]
enum RunError<'a> {
  ArgumentCountMismatch{recipe: &'a str, found: usize, min: usize, max: usize},
  Code{recipe: &'a str, code: i32},
  InternalError{message: String},
  IoError{recipe: &'a str, io_error: io::Error},
  NonLeadingRecipeWithParameters{recipe: &'a str},
  Signal{recipe: &'a str, signal: i32},
  TmpdirIoError{recipe: &'a str, io_error: io::Error},
  UnknownFailure{recipe: &'a str},
  UnknownRecipes{recipes: Vec<&'a str>, suggestion: Option<&'a str>},
  UnknownOverrides{overrides: Vec<&'a str>},
  BacktickCode{token: Token<'a>, code: i32},
  BacktickIoError{token: Token<'a>, io_error: io::Error},
  BacktickSignal{token: Token<'a>, signal: i32},
  BacktickUtf8Error{token: Token<'a>, utf8_error: std::str::Utf8Error},
  BacktickUnknownFailure{token: Token<'a>},
}

impl<'a> Display for RunError<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    let red = maybe_red(f.alternate());
    let bold = maybe_bold(f.alternate());
    write!(f, "{} {}", red.paint("error:"), bold.prefix())?;

    let mut error_token = None;

    match *self {
      RunError::UnknownRecipes{ref recipes, ref suggestion} => {
        write!(f, "Justfile does not contain recipe{} {}.",
                  maybe_s(recipes.len()), Or(&ticks(&recipes)))?;
        if let Some(suggestion) = *suggestion {
          write!(f, "\nDid you mean `{}`?", suggestion)?;
        }
      },
      RunError::UnknownOverrides{ref overrides} => {
        write!(f, "Variable{} {} overridden on the command line but not present in justfile",
                  maybe_s(overrides.len()),
                  And(&overrides.iter().map(Tick).collect::<Vec<_>>()))?;
      },
      RunError::NonLeadingRecipeWithParameters{recipe} => {
        write!(f, "Recipe `{}` takes arguments and so must be the first and only recipe \
                   specified on the command line", recipe)?;
      },
      RunError::ArgumentCountMismatch{recipe, found, min, max} => {
        if min == max {
          let expected = min;
          write!(f, "Recipe `{}` got {} argument{} but {}takes {}",
                    recipe, found, maybe_s(found),
                    if expected < found { "only " } else { "" }, expected)?;
        } else if found < min {
          write!(f, "Recipe `{}` got {} argument{} but takes at least {}",
                    recipe, found, maybe_s(found), min)?;
        } else if found > max {
          write!(f, "Recipe `{}` got {} argument{} but takes at most {}",
                    recipe, found, maybe_s(found), max)?;
        }
      },
      RunError::Code{recipe, code} => {
        write!(f, "Recipe `{}` failed with exit code {}", recipe, code)?;
      },
      RunError::Signal{recipe, signal} => {
        write!(f, "Recipe `{}` wast terminated by signal {}", recipe, signal)?;
      }
      RunError::UnknownFailure{recipe} => {
        write!(f, "Recipe `{}` failed for an unknown reason", recipe)?;
      },
      RunError::IoError{recipe, ref io_error} => {
        match io_error.kind() {
          io::ErrorKind::NotFound => write!(f,
            "Recipe `{}` could not be run because just could not find `sh` the command:\n{}",
            recipe, io_error),
          io::ErrorKind::PermissionDenied => write!(
            f, "Recipe `{}` could not be run because just could not run `sh`:\n{}",
            recipe, io_error),
          _ => write!(f, "Recipe `{}` could not be run because of an IO error while \
                      launching `sh`:\n{}", recipe, io_error),
        }?;
      },
      RunError::TmpdirIoError{recipe, ref io_error} =>
        write!(f, "Recipe `{}` could not be run because of an IO error while trying \
                  to create a temporary directory or write a file to that directory`:\n{}",
                  recipe, io_error)?,
      RunError::BacktickCode{code, ref token} => {
        write!(f, "backtick failed with exit code {}\n", code)?;
        error_token = Some(token);
      }
      RunError::BacktickSignal{ref token, signal} => {
        write!(f, "backtick was terminated by signal {}", signal)?;
        error_token = Some(token);
      }
      RunError::BacktickUnknownFailure{ref token} => {
        write!(f, "backtick failed for an uknown reason")?;
        error_token = Some(token);
      }
      RunError::BacktickIoError{ref token, ref io_error} => {
        match io_error.kind() {
          io::ErrorKind::NotFound => write!(
            f, "backtick could not be run because just could not find `sh` the command:\n{}",
            io_error),
          io::ErrorKind::PermissionDenied => write!(
            f, "backtick could not be run because just could not run `sh`:\n{}", io_error),
          _ => write!(f, "backtick could not be run because of an IO \
                          error while launching `sh`:\n{}", io_error),
        }?;
        error_token = Some(token);
      }
      RunError::BacktickUtf8Error{ref token, ref utf8_error} => {
        write!(f, "backtick succeeded but stdout was not utf8: {}", utf8_error)?;
        error_token = Some(token);
      }
      RunError::InternalError{ref message} => {
        write!(f, "internal error, this may indicate a bug in just: {} \
                   consider filing an issue: https://github.com/casey/just/issues/new",
                   message)?;
      }
    }

    write!(f, "{}", bold.suffix())?;

    if let Some(token) = error_token {
      write_token_error_context(f, token)?;
    }

    Ok(())
  }
}

#[derive(Debug, PartialEq, Clone)]
struct Token<'a> {
  index:  usize,
  line:   usize,
  column: usize,
  text:   &'a str,
  prefix: &'a str,
  lexeme: &'a str,
  kind:   TokenKind,
}

impl<'a> Token<'a> {
  fn error(&self, kind: ErrorKind<'a>) -> Error<'a> {
    Error {
      text:   self.text,
      index:  self.index + self.prefix.len(),
      line:   self.line,
      column: self.column + self.prefix.len(),
      width:  Some(self.lexeme.len()),
      kind:   kind,
    }
  }
}

#[derive(Debug, PartialEq, Clone, Copy)]
enum TokenKind {
  Backtick,
  Colon,
  Comment,
  Dedent,
  Eof,
  Eol,
  Equals,
  Indent,
  InterpolationEnd,
  InterpolationStart,
  Line,
  Name,
  Plus,
  StringToken,
  RawString,
  Text,
}

impl Display for TokenKind {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    write!(f, "{}", match *self {
      Backtick           => "backtick",
      Colon              => "\":\"",
      Comment            => "comment",
      Dedent             => "dedent",
      Eof                => "end of file",
      Eol                => "end of line",
      Equals             => "\"=\"",
      Indent             => "indent",
      InterpolationEnd   => "}}",
      InterpolationStart => "{{",
      Line               => "command",
      Name               => "name",
      Plus               => "\"+\"",
      StringToken        => "string",
      RawString          => "raw string",
      Text               => "command text",
    })
  }
}

use TokenKind::*;

fn token(pattern: &str) -> Regex {
  let mut s = String::new();
  s += r"^(?m)([ \t]*)(";
  s += pattern;
  s += ")";
  re(&s)
}

fn tokenize(text: &str) -> Result<Vec<Token>, Error> {
  lazy_static! {
    static ref BACKTICK:                  Regex = token(r"`[^`\n\r]*`"               );
    static ref COLON:                     Regex = token(r":"                         );
    static ref COMMENT:                   Regex = token(r"#([^!].*)?$"               );
    static ref EOF:                       Regex = token(r"(?-m)$"                    );
    static ref EOL:                       Regex = token(r"\n|\r\n"                   );
    static ref EQUALS:                    Regex = token(r"="                         );
    static ref INTERPOLATION_END:         Regex = token(r"[}][}]"                    );
    static ref INTERPOLATION_START_TOKEN: Regex = token(r"[{][{]"                    );
    static ref NAME:                      Regex = token(r"([a-zA-Z_-][a-zA-Z0-9_-]*)");
    static ref PLUS:                      Regex = token(r"[+]"                       );
    static ref STRING:                    Regex = token("\""                         );
    static ref RAW_STRING:                Regex = token(r#"'[^'\r\n]*'"#             );
    static ref INDENT:                    Regex = re(r"^([ \t]*)[^ \t\n\r]"     );
    static ref INTERPOLATION_START:       Regex = re(r"^[{][{]"                 );
    static ref LEADING_TEXT:              Regex = re(r"^(?m)(.+?)[{][{]"        );
    static ref LINE:                      Regex = re(r"^(?m)[ \t]+[^ \t\n\r].*$");
    static ref TEXT:                      Regex = re(r"^(?m)(.+)"               );
  }

  #[derive(PartialEq)]
  enum State<'a> {
    Start,
    Indent(&'a str),
    Text,
    Interpolation,
  }

  fn indentation(text: &str) -> Option<&str> {
    INDENT.captures(text).map(|captures| captures.at(1).unwrap())
  }

  let mut tokens = vec![];
  let mut rest   = text;
  let mut index  = 0;
  let mut line   = 0;
  let mut column = 0;
  let mut state  = vec![State::Start];

  macro_rules! error {
    ($kind:expr) => {{
      Err(Error {
        text:   text,
        index:  index,
        line:   line,
        column: column,
        width:  None,
        kind:   $kind,
      })
    }};
  }

  loop {
    if column == 0 {
      if let Some(kind) = match (state.last().unwrap(), indentation(rest)) {
        // ignore: was no indentation and there still isn't
        //         or current line is blank
        (&State::Start, Some("")) | (_, None) => {
          None
        }
        // indent: was no indentation, now there is
        (&State::Start, Some(current)) => {
          if mixed_whitespace(current) {
            return error!(ErrorKind::MixedLeadingWhitespace{whitespace: current})
          }
          //indent = Some(current);
          state.push(State::Indent(current));
          Some(Indent)
        }
        // dedent: there was indentation and now there isn't
        (&State::Indent(_), Some("")) => {
          // indent = None;
          state.pop();
          Some(Dedent)
        }
        // was indentation and still is, check if the new indentation matches
        (&State::Indent(previous), Some(current)) => {
          if !current.starts_with(previous) {
            return error!(ErrorKind::InconsistentLeadingWhitespace{
              expected: previous,
              found: current
            });
          }
          None
        }
        // at column 0 in some other state: this should never happen
        (&State::Text, _) | (&State::Interpolation, _) => {
          return error!(ErrorKind::InternalError{
            message: "unexpected state at column 0".to_string()
          });
        }
      } {
        tokens.push(Token {
          index:  index,
          line:   line,
          column: column,
          text:   text,
          prefix: "",
          lexeme: "",
          kind:   kind,
        });
      }
    }

    // insert a dedent if we're indented and we hit the end of the file
    if &State::Start != state.last().unwrap() && EOF.is_match(rest) {
      tokens.push(Token {
        index:  index,
        line:   line,
        column: column,
        text:   text,
        prefix: "",
        lexeme: "",
        kind:   Dedent,
      });
    }

    let (prefix, lexeme, kind) = 
    if let (0, &State::Indent(indent), Some(captures)) = 
      (column, state.last().unwrap(), LINE.captures(rest)) {
      let line = captures.at(0).unwrap();
      if !line.starts_with(indent) {
        return error!(ErrorKind::InternalError{message: "unexpected indent".to_string()});
      }
      state.push(State::Text);
      (&line[0..indent.len()], "", Line)
    } else if let Some(captures) = EOF.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Eof)
    } else if let State::Text = *state.last().unwrap() {
      if let Some(captures) = INTERPOLATION_START.captures(rest) {
        state.push(State::Interpolation);
        ("", captures.at(0).unwrap(), InterpolationStart)
      } else if let Some(captures) = LEADING_TEXT.captures(rest) {
        ("", captures.at(1).unwrap(), Text)
      } else if let Some(captures) = TEXT.captures(rest) {
        ("", captures.at(1).unwrap(), Text)
      } else if let Some(captures) = EOL.captures(rest) {
        state.pop();
        (captures.at(1).unwrap(), captures.at(2).unwrap(), Eol)
      } else {
        return error!(ErrorKind::InternalError{
          message: format!("Could not match token in text state: \"{}\"", rest)
        });
      }
    } else if let Some(captures) = INTERPOLATION_START_TOKEN.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), InterpolationStart)
    } else if let Some(captures) = INTERPOLATION_END.captures(rest) {
      if state.last().unwrap() == &State::Interpolation {
        state.pop();
      }
      (captures.at(1).unwrap(), captures.at(2).unwrap(), InterpolationEnd)
    } else if let Some(captures) = NAME.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Name)
    } else if let Some(captures) = EOL.captures(rest) {
      if state.last().unwrap() == &State::Interpolation {
        return error!(ErrorKind::InternalError { 
          message: "hit EOL while still in interpolation state".to_string()
        });
      }
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Eol)
    } else if let Some(captures) = BACKTICK.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Backtick)
    } else if let Some(captures) = COLON.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Colon)
    } else if let Some(captures) = PLUS.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Plus)
    } else if let Some(captures) = EQUALS.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Equals)
    } else if let Some(captures) = COMMENT.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), Comment)
    } else if let Some(captures) = RAW_STRING.captures(rest) {
      (captures.at(1).unwrap(), captures.at(2).unwrap(), RawString)
    } else if let Some(captures) = STRING.captures(rest) {
      let prefix = captures.at(1).unwrap();
      let contents = &rest[prefix.len()+1..];
      if contents.is_empty() {
        return error!(ErrorKind::UnterminatedString);
      }
      let mut len = 0;
      let mut escape = false;
      for c in contents.chars() { 
        if c == '\n' || c == '\r' {
          return error!(ErrorKind::UnterminatedString);
        } else if !escape && c == '"' {
          break;
        } else if !escape && c == '\\' {
          escape = true;
        } else if escape {
          escape = false;
        }
        len += c.len_utf8();
      }
      let start = prefix.len();
      let content_end = start + len + 1;
      if escape || content_end >= rest.len() {
        return error!(ErrorKind::UnterminatedString);
      }
      (prefix, &rest[start..content_end + 1], StringToken)
    } else if rest.starts_with("#!") {
      return error!(ErrorKind::OuterShebang)
    } else {
      return error!(ErrorKind::UnknownStartOfToken)
    };

    let len = prefix.len() + lexeme.len();

    tokens.push(Token {
      index:  index,
      line:   line,
      column: column,
      prefix: prefix,
      text:   text,
      lexeme: lexeme,
      kind:   kind,
    });

    if len == 0 {
      let last = tokens.last().unwrap();
      match last.kind {
        Eof => {},
        _ => return Err(last.error(ErrorKind::InternalError{
          message: format!("zero length token: {:?}", last)
        })),
      }
    }

    match tokens.last().unwrap().kind {
      Eol => {
        line += 1;
        column = 0;
      },
      Eof => {
        break;
      },
      _ => {
        column += len;
      }
    }

    rest = &rest[len..];
    index += len;
  }

  Ok(tokens)
}

fn parse(text: &str) -> Result<Justfile, Error> {
  let tokens = tokenize(text)?;
  let filtered: Vec<_> = tokens.into_iter().filter(|token| token.kind != Comment).collect();
  let parser = Parser {
    text:              text,
    tokens:            itertools::put_back(filtered),
    recipes:           Map::<&str, Recipe>::new(),
    assignments:       Map::<&str, Expression>::new(),
    assignment_tokens: Map::<&str, Token>::new(),
    exports:           Set::<&str>::new(),
  };
  parser.file()
}

struct Parser<'a> {
  text:              &'a str,
  tokens:            itertools::PutBack<std::vec::IntoIter<Token<'a>>>,
  recipes:           Map<&'a str, Recipe<'a>>,
  assignments:       Map<&'a str, Expression<'a>>,
  assignment_tokens: Map<&'a str, Token<'a>>,
  exports:           Set<&'a str>,
}

impl<'a> Parser<'a> {
  fn peek(&mut self, kind: TokenKind) -> bool {
    let next = self.tokens.next().unwrap();
    let result = next.kind == kind;
    self.tokens.put_back(next);
    result
  }

  fn accept(&mut self, kind: TokenKind) -> Option<Token<'a>> {
    if self.peek(kind) {
      self.tokens.next()
    } else {
      None
    }
  }

  fn accept_any(&mut self, kinds: &[TokenKind]) -> Option<Token<'a>> {
    for kind in kinds {
      if self.peek(*kind) {
        return self.tokens.next();
      }
    }
    None
  }

  fn accepted(&mut self, kind: TokenKind) -> bool {
    self.accept(kind).is_some()
  }

  fn expect(&mut self, kind: TokenKind) -> Option<Token<'a>> {
    if self.peek(kind) {
      self.tokens.next();
      None
    } else {
      self.tokens.next()
    }
  }

  fn expect_eol(&mut self) -> Option<Token<'a>> {
    if self.peek(Eol) {
      self.accept(Eol);
      None
    } else if self.peek(Eof) {
      None
    } else {
      self.tokens.next()
    }
  }

  fn unexpected_token(&self, found: &Token<'a>, expected: &[TokenKind]) -> Error<'a> {
    found.error(ErrorKind::UnexpectedToken {
      expected: expected.to_vec(),
      found:    found.kind,
    })
  }

  fn recipe(&mut self, name: Token<'a>) -> Result<(), Error<'a>> {
    if let Some(recipe) = self.recipes.get(name.lexeme) {
      return Err(name.error(ErrorKind::DuplicateRecipe {
        recipe: recipe.name,
        first:  recipe.line_number
      }));
    }

    let mut parsed_parameter_with_default = false;
    let mut parameters: Vec<Parameter> = vec![];
    while let Some(parameter) = self.accept(Name) {
      if parameters.iter().any(|p| p.name == parameter.lexeme) {
        return Err(parameter.error(ErrorKind::DuplicateParameter {
          recipe: name.lexeme, parameter: parameter.lexeme
        }));
      }
    
      let default;
      if self.accepted(Equals) {
        if let Some(string) = self.accept_any(&[StringToken, RawString]) {
          default = Some(cook_string(&string)?.cooked);
        } else {
          let unexpected = self.tokens.next().unwrap();
          return Err(self.unexpected_token(&unexpected, &[StringToken, RawString]));
        }
      } else {
        default = None
      }

      if parsed_parameter_with_default && default.is_none() {
        return Err(parameter.error(ErrorKind::RequiredParameterFollowsDefaultParameter{
          parameter: parameter.lexeme,
        }));
      }

      parsed_parameter_with_default |= default.is_some();

      parameters.push(Parameter {
        name:    parameter.lexeme,
        default: default,
        token:   parameter,
      });
    }

    if let Some(token) = self.expect(Colon) {
      // if we haven't accepted any parameters, an equals
      // would have been fine as part of an assignment
      if parameters.is_empty() {
        return Err(self.unexpected_token(&token, &[Name, Colon, Equals]));
      } else {
        return Err(self.unexpected_token(&token, &[Name, Colon]));
      }
    }

    let mut dependencies = vec![];
    let mut dependency_tokens = vec![];
    while let Some(dependency) = self.accept(Name) {
      if dependencies.contains(&dependency.lexeme) {
        return Err(dependency.error(ErrorKind::DuplicateDependency {
          recipe:     name.lexeme,
          dependency: dependency.lexeme
        }));
      }
      dependencies.push(dependency.lexeme);
      dependency_tokens.push(dependency);
    }

    if let Some(token) = self.expect_eol() {
      return Err(self.unexpected_token(&token, &[Name, Eol, Eof]));
    }

    let mut lines = vec![];
    let mut shebang = false;

    if self.accepted(Indent) {
      while !self.accepted(Dedent) {
        if self.accepted(Eol) {
          continue;
        }
        if let Some(token) = self.expect(Line) {
          return Err(token.error(ErrorKind::InternalError{
            message: format!("Expected a line but got {}", token.kind)
          }))
        }
        let mut pieces = vec![];

        while !(self.accepted(Eol) || self.peek(Dedent)) {
          if let Some(token) = self.accept(Text) {
            if pieces.is_empty() {
              if lines.is_empty() {
                if token.lexeme.starts_with("#!") {
                  shebang = true;
                }
              } else if !shebang && (token.lexeme.starts_with(' ') || 
                                     token.lexeme.starts_with('\t')) {
                return Err(token.error(ErrorKind::ExtraLeadingWhitespace));
              }
            }
            pieces.push(Fragment::Text{text: token});
          } else if let Some(token) = self.expect(InterpolationStart) {
            return Err(self.unexpected_token(&token, &[Text, InterpolationStart, Eol]));
          } else {
            pieces.push(Fragment::Expression{
              expression: self.expression(true)?
            });
            if let Some(token) = self.expect(InterpolationEnd) {
              return Err(self.unexpected_token(&token, &[InterpolationEnd]));
            }
          }
        }

        lines.push(pieces);
      }
    }

    self.recipes.insert(name.lexeme, Recipe {
      line_number:       name.line,
      name:              name.lexeme,
      dependencies:      dependencies,
      dependency_tokens: dependency_tokens,
      parameters:        parameters,
      lines:             lines,
      shebang:           shebang,
    });

    Ok(())
  }

  fn expression(&mut self, interpolation: bool) -> Result<Expression<'a>, Error<'a>> {
    let first = self.tokens.next().unwrap();
    let lhs = match first.kind {
      Name        => Expression::Variable {name: first.lexeme, token: first},
      Backtick    => Expression::Backtick {
        raw:   &first.lexeme[1..first.lexeme.len()-1],
        token: first
      },
      RawString | StringToken => {
        Expression::String{cooked_string: cook_string(&first)?}
      }
      _ => return Err(self.unexpected_token(&first, &[Name, StringToken])),
    };

    if self.accepted(Plus) {
      let rhs = self.expression(interpolation)?;
      Ok(Expression::Concatination{lhs: Box::new(lhs), rhs: Box::new(rhs)})
    } else if interpolation && self.peek(InterpolationEnd) {
      Ok(lhs)
    } else if let Some(token) = self.expect_eol() {
      if interpolation {
        return Err(self.unexpected_token(&token, &[Plus, Eol, InterpolationEnd]))
      } else {
        Err(self.unexpected_token(&token, &[Plus, Eol]))
      }
    } else {
      Ok(lhs)
    }
  }

  fn assignment(&mut self, name: Token<'a>, export: bool) -> Result<(), Error<'a>> {
    if self.assignments.contains_key(name.lexeme) {
      return Err(name.error(ErrorKind::DuplicateVariable {variable: name.lexeme}));
    }
    if export {
      self.exports.insert(name.lexeme);
    }
    let expression = self.expression(false)?;
    self.assignments.insert(name.lexeme, expression);
    self.assignment_tokens.insert(name.lexeme, name);
    Ok(())
  }

  fn file(mut self) -> Result<Justfile<'a>, Error<'a>> {
    loop {
      match self.tokens.next() {
        Some(token) => match token.kind {
          Eof => break,
          Eol => continue,
          Name => if token.lexeme == "export" {
            let next = self.tokens.next().unwrap();
            if next.kind == Name && self.accepted(Equals) {
              self.assignment(next, true)?;
            } else {
              self.tokens.put_back(next);
              self.recipe(token)?;
            }
          } else if self.accepted(Equals) {
            self.assignment(token, false)?;
          } else {
            self.recipe(token)?;
          },
          Comment => return Err(token.error(ErrorKind::InternalError {
            message: "found comment in token stream".to_string()
          })),
          _ => return return Err(self.unexpected_token(&token, &[Name])),
        },
        None => return Err(Error {
          text:   self.text,
          index:  0,
          line:   0,
          column: 0,
          width:  None,
          kind:   ErrorKind::InternalError {
            message: "unexpected end of token stream".to_string()
          }
        }),
      }
    }

    if let Some(token) = self.tokens.next() {
      return Err(token.error(ErrorKind::InternalError{
        message: format!("unexpected token remaining after parsing completed: {:?}", token.kind)
      }))
    }

    resolve_recipes(&self.recipes, &self.assignments, self.text)?;

    for recipe in self.recipes.values() {
      for parameter in &recipe.parameters {
        if self.assignments.contains_key(parameter.token.lexeme) {
          return Err(parameter.token.error(ErrorKind::ParameterShadowsVariable {
            parameter: parameter.token.lexeme
          }));
        }
      }

      for dependency in &recipe.dependency_tokens {
        if !self.recipes[dependency.lexeme].parameters.is_empty() {
          return Err(dependency.error(ErrorKind::DependencyHasParameters {
            recipe: recipe.name,
            dependency: dependency.lexeme,
          }));
        }
      }
    }

    resolve_assignments(&self.assignments, &self.assignment_tokens)?;

    Ok(Justfile {
      recipes:     self.recipes,
      assignments: self.assignments,
      exports:     self.exports,
    })
  }
}