1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

extern crate console;

use language::bash;
use language::c;
use language::cpp;
use language::csharp;
use language::css;
use language::golang;
use language::html;
use language::java;
use language::javascript;
use language::lua;
use language::php;
use language::python;
use language::ruby;
use language::rust;
use language::scala;
use language::FileType;
use language::FindResult;
use language::Language;
use std::io::Error;
use std::io::ErrorKind;
use std::path::Path;
use utils::comments::noop_find_result;
use utils::path::extension;

pub mod language;
pub mod printer;
pub mod utils;

pub struct OptionsCli {
    pub extension: Option<String>,
}

pub fn run(paths: Vec<&Path>, opts: OptionsCli) -> Vec<Result<FindResult, Error>> {
    paths
        .into_iter()
        .map(|path| resolve_type_and_run(path, &opts))
        .collect::<Vec<Result<FindResult, Error>>>()
}

pub fn resolve_type_and_run(p: &Path, opts: &OptionsCli) -> Result<FindResult, Error> {
    let unsupported_err = Err(Error::new(
        ErrorKind::NotFound,
        "Unsupported file extension",
    ));

    if exclude_file(p, opts) {
        return Ok(noop_find_result());
    }

    match p.extension() {
        None => unsupported_err,
        Some(_ext) => match _ext.to_str() {
            None => panic!("Could not convert OsStr -> str"),
            Some(extension) => match extension {
                "c" => Ok(run_source(FileType::C, p)?),
                "cpp" => Ok(run_source(FileType::Cpp, p)?),
                "cs" => Ok(run_source(FileType::CSharp, p)?),
                "css" => Ok(run_source(FileType::CSS, p)?),
                "go" => Ok(run_source(FileType::Go, p)?),
                "html" => Ok(run_source(FileType::HTML, p)?),
                "java" => Ok(run_source(FileType::Java, p)?),
                "js" => Ok(run_source(FileType::JavaScript, p)?),
                "lua" => Ok(run_source(FileType::Lua, p)?),
                "php" => Ok(run_source(FileType::PHP, p)?),
                "py" => Ok(run_source(FileType::Python, p)?),
                "rb" => Ok(run_source(FileType::Ruby, p)?),
                "rs" => Ok(run_source(FileType::Rust, p)?),
                "sc" => Ok(run_source(FileType::Scala, p)?),
                "scala" => Ok(run_source(FileType::Scala, p)?),
                "sh" => Ok(run_source(FileType::Bash, p)?),
                _ => unsupported_err,
            },
        },
    }
}

fn run_source(file_type: FileType, p: &Path) -> Result<FindResult, Error> {
    match file_type {
        FileType::Bash => bash::source(p).find(),
        FileType::C => c::source(p).find(),
        FileType::CSS => css::source(p).find(),
        FileType::CSharp => csharp::source(p).find(),
        FileType::Cpp => cpp::source(p).find(),
        FileType::Go => golang::source(p).find(),
        FileType::HTML => html::source(p).find(),
        FileType::Java => java::source(p).find(),
        FileType::JavaScript => javascript::source(p).find(),
        FileType::Lua => lua::source(p).find(),
        FileType::PHP => php::source(p).find(),
        FileType::Python => python::source(p).find(),
        FileType::Ruby => ruby::source(p).find(),
        FileType::Rust => rust::source(p).find(),
        FileType::Scala => scala::source(p).find(),
    }
}

fn exclude_file(p: &Path, opts: &OptionsCli) -> bool {
    match &opts.extension {
        None => false,
        Some(ext_options) => match extension(p) {
            Ok(ext_file) => {
                if ext_options == &ext_file {
                    false
                } else {
                    true
                }
            }
            Err(e) => panic!("{:?}", e),
        },
    }
}