arithmancy 0.0.1

an *advanced* mathematical compilation
Documentation 
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
114
115
116
117
118
119

//! Build configuration

extern crate tinyrick;

use std::env;
use std::process::Command;

/// Run clippy
fn clippy() {
  Command::new("cargo")
    .arg("clippy")
    .status()
    .expect("Error running clippy");
}

/// Run linters
fn lint() {
  tinyrick::deps(clippy);
}

/// Compile project
fn build() {
  Command::new("cargo")
    .arg("build")
    .status()
    .expect("Error building project");
}

/// Install project
fn install() {
  Command::new("cargo")
    .args(&["install", "--force", "--path", "."])
    .status()
    .expect("Error installing project");
}

/// Uninstall project
fn uninstall() {
  Command::new("cargo")
    .args(&["uninstall", "arithmancy"])
    .status()
    .expect("Error installing project");
}

/// Run unit tests
fn unit_test() {
  Command::new("cargo")
    .arg("test")
    .status()
    .expect("Error during tests");
}

/// Run integration tests
fn integration_test() {
  tinyrick::deps(build);

  let bin = "add_two";

  let output = Command::new(bin)
    .args(&["-n", "2"])
    .output()
    .expect(&format!("Error running binary {}", bin));

  String::from_utf8(output.stdout)
    .map(|stdout| { assert!(stdout == "4\n") })
    .expect(&format!("Error parsing stdout as UTF-8 on binary {}", bin));
}

/// Run all tests
fn test() {
  tinyrick::deps(unit_test);
  tinyrick::deps(integration_test);
}

/// Show banner
fn banner() {
  Command::new("add_two")
    .arg("-v")
    .status()
    .expect("Error running 'add_two -v'");
}

/// Publish to crate repository
fn publish() {
  Command::new("cargo")
    .arg("publish")
    .status()
    .expect("Error publishing package");
}

pub fn main() {
  let args : Vec<String> = env::args().collect();

  let task_names : Vec<&str> = args
    .iter()
    .skip(1)
    .map(String::as_str)
    .collect();

  if task_names.len() == 0 {
    test();
  } else {
    for task_name in task_names {
      match task_name {
        "clippy" => clippy(),
        "lint" => lint(),
        "build" => build(),
        "install" => install(),
        "uninstall" => uninstall(),
        "unit_test" => unit_test(),
        "integration_test" => integration_test(),
        "test" => test(),
        "banner" => banner(),
        "publish" => publish(),
        _ => panic!("Unknown task {}", task_name)
      }
    }
  }
}