spor 0.3.0

Anchored metadata
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

use std::fs;
use std::io::Write;
use std::process::{Command, Stdio};

use super::super::world::World;

use cucumber_rust::steps;

steps!(World => {

        given "I initialize a repository" |world, _step| {
            Command::new(&world.executable)
                .arg("init")
                .output()
                .expect("failed to execute spor");
        };

        given regex r"^I create the source file (.+)$" (String) |world, filename, _step| {
            let source_file = world.repo_dir.join(filename);
            let code = "def func():
    x = 1
    y = 2
    z = 3
    return x + y + z";
            fs::write(source_file, code)
                .expect("unable to write code to test file");
        };

        then regex r"^anchoring an external file fails$" () |world, _step| {
            let source_file = world.external_dir.join("external.py");
            let code = "# nothing";
            fs::write(&source_file, code)
                .expect("unable to write to test file");

            let mut cmd = Command::new(&world.executable)
                .arg("add")
                .arg(source_file)
                .arg("1")
                .arg("1")
                .arg("1")
                .stdin(Stdio::piped())
                .spawn()
                .expect("failed to execute spor");

            {
                let stdin = cmd.stdin.as_mut()
                    .expect("Failed to open stdin");
                stdin.write_all("{meta: data}".as_bytes())
                    .expect("Failed to write to stdin");
            }

            let exit_status = cmd.wait().expect("Command should fail.");
            assert!(!exit_status.success());
        };

        when regex r"^I modify (.+)$" (String) |world, filename, _step| {
            let source_file = world.repo_dir.join(filename);
            let code = fs::read_to_string(&source_file)
                .expect("Unable to read source file");
            let code = String::from("# a comment\n") + &code;
            fs::write(source_file, code)
                .expect("unable to write code to test file");
        };

        then "a repo data directory exists" |world, _step| {
            assert!(world.repo_dir.join(".spor").exists());
        };

        when regex r"^I create a new anchor for (.+) at offset (\d+)$" (String, usize) |world, filename, offset, _step| {
            let mut cmd = Command::new(&world.executable)
                .arg("add")
                .arg(filename)
                .arg(offset.to_string())
                .arg("5")
                .arg("5")
                .stdin(Stdio::piped())
                .spawn()
                .expect("failed to execute spor");

            {
                let stdin = cmd.stdin.as_mut()
                    .expect("Failed to open stdin");
                stdin.write_all("{meta: data}".as_bytes())
                    .expect("Failed to write to stdin");
            }

            let output = cmd.wait_with_output()
                .expect("Failed to read stdout");

            assert_eq!(String::from_utf8_lossy(&output.stdout), "");
        };

        then regex r"^an anchor for (.+) at line (\d+) appears in the listing$" (String, usize) |world, filename, _lineno, _step| {
            let output = Command::new(&world.executable)
                .arg("list")
                .arg(filename)
                .output()
                .expect("failed to execute spor");
            let output = String::from_utf8_lossy(&output.stdout);
            let output: Vec<&str> = output.split("\n").filter(|s| !s.is_empty()).collect();
            assert_eq!(output.len(), 1);

            // TODO: Look for correct output, e.g. it contains filename, has the right line number, etc.
        };

        then "the repository is valid" |world, _step| {
            let output = Command::new(&world.executable)
                .arg("status")
                .output()
                .expect("failed to execute spor");
            let output = String::from_utf8_lossy(&output.stdout);
            let output: Vec<&str> = output.split("\n").filter(|s| !s.is_empty()).collect();
            assert!(output.is_empty());
        };

        then "the repository is invalid" |world, _step| {
            let output = Command::new(&world.executable)
                .arg("status")
                .output()
                .expect("failed to execute spor");
            let output = String::from_utf8_lossy(&output.stdout);
            let output: Vec<&str> = output.split("\n").filter(|s| !s.is_empty()).collect();
            assert!(!output.is_empty());
        };


    });