whiley 0.6.3

A command-line build tool and package manager for Whiley.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

use std::error::Error;
use std::path::{Path,PathBuf};
use glob::glob;
use crate::config;
use crate::config::{Config,Key};
use crate::build;
use crate::build::{PACKAGE_NAME,Artifact};
use crate::jvm;
use crate::platform;
use crate::platform::{PluginError};

/// Default setting for whether building library or binary.
pub static LIBRARY_DEFAULT : bool = true;
/// Default path for whiley source files.
pub static SOURCE_DEFAULT : &'static str = "src";
/// Default path for whiley binary files.
pub static TARGET_DEFAULT : &'static str = "bin";
/// Default set of includes for whiley files
pub static INCLUDES_DEFAULT : &'static str = "**/*.whiley";
/// Default main method to execute
pub static MAIN_DEFAULT : &'static str = "main::main";

pub static DEPENDENCIES : Key = Key::new(&["dependencies"]);
pub static BUILD_WHILEY_SOURCE : Key = Key::new(&["build","whiley","source"]);
pub static BUILD_WHILEY_TARGET : Key = Key::new(&["build","whiley","target"]);
pub static BUILD_WHILEY_INCLUDES : Key = Key::new(&["build","whiley","includes"]);
pub static BUILD_WHILEY_LIBRARY : Key = Key::new(&["build","whiley","library"]);
pub static BUILD_WHILEY_MAIN : Key = Key::new(&["build","whiley","main"]);

// ========================================================================
// Platform
// ========================================================================

/// Identify the necessary dependencies (from Maven central) necessary
/// to run the WhileyCompiler.
pub static MAVEN_DEPS : &'static [&str] = &[
    "org.whiley:jmodelgen:0.4.3",
    "org.whiley:wyc:0.10.18",
];

pub struct WhileyPlatform {
    name: String,
    linking: bool,
    source: PathBuf,
    target: PathBuf,
    includes: String,
    whileypath: Vec<String>
}

impl WhileyPlatform {
    /// Match all whiley files to be compiled for this package.
    fn match_includes(&self) -> Vec<String> {
        // TODO: this is all rather ugly if you ask me.
	let mut matches = Vec::new();
        let mut includes = PathBuf::new();
	includes.push(&self.source);
        includes.push(self.includes.as_str());
	let mut sincludes = includes.to_str().unwrap();
        //
        for entry in glob(&sincludes).expect("invalid pattern for key \"build.whiley.includes\"") {
            match entry {
                Ok(path) => {
                    //let f = path.into_os_string().into_string().unwrap();
                    //let n = self.source.len()+1;
		    let f = path.strip_prefix(&self.source).unwrap();
                    matches.push(f.to_str().unwrap().to_string());
                }
                Err(e) => println!("{:?}", e)
            }
        }
	// Done
	matches
    }
    // Determine the fully qualified path of the target file.
    fn target_path(&self) -> PathBuf {
	let mut bin = PathBuf::from(&self.target);
	let mut name = self.name.clone();
	name.push_str(".wyil");
	bin.push(&name);
	bin
    }
}

impl platform::JavaInstance for WhileyPlatform {
    fn name(&self) -> &'static str {
        "whiley"
    }
    fn dependencies(&self) -> &'static [&'static str] {
	MAVEN_DEPS
    }
    fn arguments(&self) -> Vec<String> {
        let mut args = Vec::new();
        // Class to invoke
        args.push("wyc.Compiler".to_string());
        // Target name
        args.push("-o".to_string());
        args.push(self.name.clone());
	//
	if self.linking {
	    // Enable linking
	    args.push("--linking".to_string());
	}
        // Whiley source dir
        let mut source = String::new();
        source.push_str("--whileydir=");
        source.push_str(self.source.to_str().unwrap());
        args.push(source);
        // Whiley bin dir
        let mut target = String::new();
        target.push_str("--wyildir=");
        target.push_str(self.target.to_str().unwrap());
        args.push(target);
        // Whiley path
        let mut whileypath = String::new();
        if self.whileypath.len() > 0 {
            whileypath.push_str("--whileypath=");
            whileypath.push_str(self.whileypath.get(0).unwrap());
            for e in &self.whileypath[1..] {
                whileypath.push_str(jvm::classpath_sep());
                whileypath.push_str(e);
            }
	    args.push(whileypath);
        }
        //
        args.append(&mut self.match_includes());
        //
        args
    }
    fn manifest(&self) -> Vec<build::Artifact> {
	let mut artifacts = Vec::new();
	// Register the binary artifact
	let bin = self.target_path();
	artifacts.push(Artifact::BinaryFolder(PathBuf::from(&self.target)));
	artifacts.push(Artifact::BinaryFile(bin,true));
	artifacts.push(Artifact::SourceFolder(PathBuf::from(&self.source)));
	for i in self.match_includes() {
	    let mut p = PathBuf::from(&self.source);
	    p.push(i);
	    artifacts.push(Artifact::SourceFile(p));
	}
	//
	artifacts
    }
    fn process(&self, output: &str) -> Result<Vec<build::Marker>,Box<dyn Error>> {
	match parse_output(&self.source,output) {
	    Some(markers) => Ok(markers),
	    None => {
		Err(Box::new(PluginError{name:"wyc".to_string(),message: output.to_string()}))
	    }
	}
    }
}

pub fn parse_output(source: &PathBuf, output: &str) -> Option<Vec<build::Marker>> {
    let mut markers = Vec::new();
    // Process each line of output
    for line in output.lines() {
	// Split line into components
	let split : Vec<&str> = line.split("|").collect();
	if split.len() != 5 {
	    return None;
	}
	// Parse components
	let kind = build::Kind::SyntaxError;
	let mut path = source.clone();
	path.push(split[0]);
	let start = split[1].parse();
	let end = split[2].parse();
	if start.is_err() || end.is_err() {
	    return None;
	}
	let message = split[4].to_string();
	// Done
	markers.push(build::Marker::new(kind,path,start.unwrap(),end.unwrap(),message));
    }
    // Done
    Some(markers)
}

// ========================================================================
// Initialiser
// ========================================================================

pub struct Descriptor {}

pub const TMP : &'static str = "dependencies";

impl platform::Descriptor for Descriptor {
    fn apply<'a>(&self, config: &'a Config, whileyhome: &Path) -> Result<platform::Instance,config::Error> {
	// Extract configuration (if any)
        let name = config.get_string(&PACKAGE_NAME)?;
	let linking = !config.get_bool(&BUILD_WHILEY_LIBRARY).unwrap_or(LIBRARY_DEFAULT);
	let source = config.get_path(&BUILD_WHILEY_SOURCE).unwrap_or(PathBuf::from(SOURCE_DEFAULT));
	let target = config.get_path(&BUILD_WHILEY_TARGET).unwrap_or(PathBuf::from(TARGET_DEFAULT));
	let includes = config.get_string(&BUILD_WHILEY_INCLUDES).unwrap_or(INCLUDES_DEFAULT.to_string());
        // Construct whileypath?
        let mut whileypath = Vec::new();
	// FIXME: this should be placed somewhere else, and use a
	// resolved.
        for s in config.find_keys(&DEPENDENCIES).unwrap_or(Vec::new()) {
            let a = [&TMP,s.as_str()];
            let k = Key::new(&a);
	    let d = config.get_string(&k)?;
	    let mut pb = PathBuf::new();
	    pb.push(whileyhome);
	    pb.push("repository");
	    pb.push(format!("{}-v{}.zip",&s,&d));
	    // FIXME: whileypath should be Vec of PathBuf
	    let arg = pb.into_os_string().into_string().unwrap();
	    whileypath.push(arg);
        }
	// Construct new instance on the heap
	let instance = Box::new(WhileyPlatform{name,linking,source,target,includes,whileypath});
	// Return generic instance
	Ok(platform::Instance::Java(instance))
    }
}

pub const DESCRIPTOR : Descriptor = Descriptor{};