penrose_proc 0.1.3

proc-macros for the Penrose tiling window manager library
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

use penrose_proc::stubbed_companion_trait;

#[derive(Debug, Eq, PartialEq)]
enum Animal {
    Cat,
    Dog,
}

#[stubbed_companion_trait]
trait Colors {
    #[stub("red")]
    fn color(&self, x: u32) -> &str;
}

#[stubbed_companion_trait]
trait AnimalsAndColors: Colors {
    #[stub(Some(Animal::Cat))]
    fn animal(&self, name: &str) -> Option<Animal>;

    fn best_animal(&self) -> Animal {
        Animal::Dog
    }

    fn colored_animal(&self, name: &str, x: u32) -> String {
        if let Some(a) = self.animal(name) {
            let color = self.color(x);
            format!("A {:?} that is {}", a, color)
        } else {
            format!("Not sure what a {} is", name)
        }
    }
}

struct ImplColors;

impl Colors for ImplColors {
    fn color(&self, x: u32) -> &str {
        match x {
            42 => "red",
            _ => "green",
        }
    }
}

#[test]
fn it_is_possible_to_impl_the_original_trait() {
    let ic = ImplColors;
    assert_eq!(ic.color(42), "red");
    assert_eq!(ic.color(19), "green");
}

struct DeriveStubbedAnimalsAndColors;

impl StubColors for DeriveStubbedAnimalsAndColors {}
impl StubAnimalsAndColors for DeriveStubbedAnimalsAndColors {}

#[test]
fn default_method_impls_are_copied() {
    let d = DeriveStubbedAnimalsAndColors;
    assert_eq!(d.best_animal(), Animal::Dog);
}

#[test]
fn trait_bounds_are_maintained() {
    let d = DeriveStubbedAnimalsAndColors;
    assert_eq!(&d.colored_animal("anything", 42), "A Cat that is red");
}

// -----

mod inner {
    #[penrose_proc::stubbed_companion_trait]
    pub trait InnerColors {
        #[stub("blue")]
        fn color(&self, x: u32) -> &str;
    }
}

use inner::InnerColors;
struct OuterImplementer;
impl inner::StubInnerColors for OuterImplementer {}

#[test]
fn visibility_of_stubs_matches_original() {
    let o = OuterImplementer;
    assert_eq!(o.color(42), "blue");
}

// -----

#[allow(dead_code)]
#[derive(Eq, PartialEq, Debug)]
enum Scale {
    Major,
    Minor,
    Blues,
}

#[stubbed_companion_trait(prefix = "CustomPrefix")]
trait Musical {
    #[stub("F#")]
    fn musical_note(&self, x: u32) -> &str;

    #[stub(Scale::Blues)]
    fn musical_scale(&self, f: f64) -> Scale;
}

struct ImplMusical;
impl CustomPrefixMusical for ImplMusical {}

#[test]
fn custom_prefix_works() {
    let i = ImplMusical;
    assert_eq!(i.musical_note(17), "F#");
    assert_eq!(i.musical_scale(3.0), Scale::Blues);
}

// -----